Organize complete final models, all ablations, logs and checkpoints with visual guides (part 7)

main_method/checkpoints/shared/attention_temporal_cnn_seed3407.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:de57690bdbae4ff182b983429e1b6c2683a9ad1fc7bfe9011a7a3cfc24f53bf3
+size 123402

main_method/checkpoints/shared/new_temporal_cnn_seed3407.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a08c3485199d8b519bf1a9dad72c84545b7adee818798acdfe068135be3de833
+size 122582

main_method/checkpoints/shared/original_temporal_cnn_seed3407.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:08ba0ec1c2409596301504f299c40b8eb20346c12241903364d74179b23a1774
+size 122582

main_method/checkpoints/shared/sam_network_seed3407.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aa834986f0756f8bcf5646f3af63d0ccbd59ad46d33f6a64641e98fe14e679f1
+size 24142864

main_method/checkpoints/shared/training_feature_cluster_centres_seed3407.tar

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3a17469c8d41370e6808f00c24fc49f8801c88a9e4715b5a19802bba9ec3fb30
+size 116521

main_method/code/augmentation.py

@@ -0,0 +1,67 @@
+import math,random
+import torch
+import config as C
+
+def aug_dihedral(xc, yc):
+    """One dihedral-8 transform per crop-batch, image and label together."""
+    if torch.rand(()) > 0.5:
+        xc, yc = xc.flip(-2), yc.flip(-2)
+    if torch.rand(()) > 0.5:
+        xc, yc = xc.flip(-1), yc.flip(-1)
+    k = int(torch.randint(0, 4, ()))
+    if k:
+        xc, yc = torch.rot90(xc, k, (-2, -1)), torch.rot90(yc, k, (-2, -1))
+    return xc.contiguous(), yc.contiguous()
+
+
+def aug_temporal_subsample(xc, pos, p=0.5, drop_max=0.2, keep_min=24):
+    """Drop up to `drop_max` of the frames, order preserved. Positions keep
+    their original index values -> emulates missing acquisitions of an
+    otherwise identical season. No-op with probability 1-p."""
+    if torch.rand(()) > p:
+        return xc, pos
+    T = xc.shape[1]
+    keep = int(round(T * (1.0 - random.uniform(0.0, drop_max))))
+    keep = max(keep_min, min(T, keep))
+    if keep >= T:
+        return xc, pos
+    idx = torch.randperm(T)[:keep].sort().values.to(xc.device)
+    return (xc.index_select(1, idx).contiguous(),
+            pos.index_select(1, idx).contiguous())
+
+
+def aug_frame_dropout(xc, p=0.25, max_frames=2):
+    """Zero 1-2 whole frames (0 == dataset mean after normalisation) —
+    emulates cloudy/lost acquisitions."""
+    if torch.rand(()) > p:
+        return xc
+    T = xc.shape[1]
+    n = random.randint(1, max_frames)
+    idx = torch.randperm(T)[:n].to(xc.device)
+    xc = xc.clone()
+    xc[:, idx] = 0.0
+    return xc
+
+
+def aug_spectral(xc, gain_std=0.05, bias_std=0.03, noise_std=0.01):
+    """Per-sample, per-band gain/bias jitter + small gaussian noise (data is
+    z-normalised, so these are fractions of one std)."""
+    B, T, Ch, H, W = xc.shape
+    dev = xc.device
+    gain = 1.0 + gain_std * torch.randn(B, 1, Ch, 1, 1, device=dev)
+    bias = bias_std * torch.randn(B, 1, Ch, 1, 1, device=dev)
+    xc = xc * gain + bias
+    if noise_std > 0:
+        xc = xc + noise_std * torch.randn_like(xc)
+    return xc.contiguous()
+
+
+def lr_factor(step, total_steps, warmup_steps, min_ratio):
+    """Linear warmup then cosine decay to min_ratio."""
+    if step < warmup_steps:
+        return (step + 1) / max(1, warmup_steps)
+    p = (step - warmup_steps) / max(1, total_steps - warmup_steps)
+    p = min(1.0, p)
+    cos = 0.5 * (1.0 + math.cos(math.pi * p))
+    return min_ratio + (1.0 - min_ratio) * cos
+

main_method/code/config.py

@@ -0,0 +1,231 @@
+"""Final method configuration. Sampling and seed match STCLN; preprocessing differences are documented in FINAL_REPORT.md."""
+import os
+from pathlib import Path
+
+# ─── Paths ──────────────────────────────────────────────────────────────────
+# Derived from this file's own location so the project moves between machines
+# without edits. Current layout on this box:
+#
+#   /home/ubuntu/tsrda/            <- REPO_ROOT = EXP_ROOT (code + checkpoints)
+#   /home/ubuntu/test/PASTIS/      <- PASTIS_ROOT (dataset)
+#
+# PASTIS_ROOT is searched in the order below; the first existing hit wins.
+# Override either root by env var, e.g.
+#   PASTIS_ROOT=/mnt/data/PASTIS python3 check_data.py
+REPO_ROOT     = Path(__file__).resolve().parents[2]
+
+_PASTIS_CANDIDATES = (
+    # Kaggle notebook locations (PASTIS-R dataset attached as an input)
+    Path("/home/ubuntu/PASTIS"),
+    Path("/home/ubuntu/PASTIS"),
+    REPO_ROOT / "PASTIS-R",
+    REPO_ROOT / "PASTIS",
+    REPO_ROOT.parent / "PASTIS",
+)
+
+
+def _find_pastis_root():
+    env = os.environ.get("PASTIS_ROOT")
+    if env:
+        return Path(env)
+    for cand in _PASTIS_CANDIDATES:
+        if (cand / "metadata.geojson").is_file():
+            return cand
+    raise FileNotFoundError(
+        "PASTIS dataset not found. Looked for metadata.geojson in:\n  "
+        + "\n  ".join(str(c) for c in _PASTIS_CANDIDATES)
+        + "\nSet the PASTIS_ROOT environment variable to the dataset directory."
+    )
+
+
+PASTIS_ROOT   = _find_pastis_root()
+DATA_S2_DIR   = PASTIS_ROOT / "DATA_S2"
+ANNOT_DIR     = PASTIS_ROOT / "ANNOTATIONS"
+META_PATH     = PASTIS_ROOT / "metadata.geojson"
+NORM_PATH     = PASTIS_ROOT / "NORM_S2_patch.json"
+
+EXP_ROOT      = Path(os.environ.get("EXP_ROOT", REPO_ROOT))
+CKPT_DIR_PRE  = EXP_ROOT / "checkpoints" / "pretrain"
+CKPT_DIR_FT   = EXP_ROOT / "checkpoints" / "finetune"
+
+# ─── Reproducibility ────────────────────────────────────────────────────────
+SEED          = 3407            # [OFFICIAL] torch.manual_seed in
+                                # finetuning_STCLN.py:25 and test_STCLN.py:11
+VARIANCE_SEEDS = (3407, 42, 1234)
+                                # [RESEARCH] additional seeds used for
+                                # seed-variance runs. Pass with --seed.
+
+# ─── Model dimensions ───────────────────────────────────────────────────────
+N_CHANNELS    = 10              # [OFFICIAL]
+D_MODEL       = 256             # [OFFICIAL]
+N_HEADS       = 8               # [OFFICIAL]
+N_CLASSES     = 20              # [OFFICIAL] 0=background, 19=void, 1-18 scored
+T_PAD         = 48              # inert; UTAE_ASPP absorbs it for constructor
+                                # compatibility and the encoder self-pads
+
+# T-SRDA schedule: KV reduction ratio per block (replaces Swin/DaViT windows).
+R_SCHEDULE    = [4, 4, 4]       # [TSRDA] the architectural variable
+
+# Legacy temporal-Swin params — kept ONLY so the train scripts' constructor
+# call sites compile unchanged. TemporalSRDAEncoder ignores them.
+TSE_WINDOWS   = [4, 8, 16]
+TSE_SHIFTS    = [0, 4, 0]
+
+# ─── Protocol: geometry ─────────────────────────────────────────────────────
+PATCH_SIZE    = 128             # [OFFICIAL] PASTIS native patch
+CROP_SIZE     = 32              # [OFFICIAL] PATCH_SIZE // 4
+REF_DATE_STR  = "2018-09-01"    # [OFFICIAL]
+USE_INDEX_POSITIONS = True      # [OFFICIAL] the model is fed torch.arange(T),
+                                # NOT real day offsets. See
+                                # finetuning_STCLN.py:198 — every forward call
+                                # passes `torch.tensor(range(T))`. Real days are
+                                # still returned by the dataset for analysis.
+
+# ─── Protocol: pretrain split ───────────────────────────────────────────────
+PRETRAIN_FOLDS     = [5]        # [OFFICIAL] 496 patches
+PRETRAIN_CROP_GRID = 4          # [OFFICIAL] inner `for i in range(4): for j in
+                                # range(4)` loop -> 16 crops per patch, each a
+                                # SEPARATE optimizer step.
+                                #   496 / 4 = 124 batches x 16 = 1,984 steps/ep
+CROPS_PER_PATCH    = PRETRAIN_CROP_GRID ** 2      # 16
+
+# ─── Protocol: finetune splits (hardcoded patch IDs, not a fold filter) ─────
+# The official script builds the dataset with folds=[1] / folds=[2] and then
+# OVERWRITES dataset.id_patches with these literal lists. Verified against
+# metadata.geojson: every train ID is fold 1, every val ID is fold 2, the two
+# sets are disjoint, and neither touches the fold-4 test set or fold-5
+# pretrain pool. Duplicates are intentional and are KEPT — they make those
+# patches count twice per epoch.
+FT_CROP_IJ = [(0, 0), (1, 1)]   # [OFFICIAL] finetuning_STCLN.py:185 — only the
+                                # first two diagonal crops of the 4x4 grid.
+                                #   76 / 2 = 38 batches x 2 crops = 76 steps/ep
+
+TRAIN_PATCH_IDS = [
+    10279, 40282, 10174, 40538, 10457, 30088, 10151, 30602, 40275, 20052,
+    20153, 10056, 20147, 40420, 10450, 20614, 20167, 40446, 20251, 20103,
+    20613, 20349, 20384, 40337, 40163, 10030, 10068, 10399, 30327, 10289,
+    30351, 40198, 20167, 20153, 20207, 20203, 10000, 10354, 20214, 10007,
+    10392, 30055, 10054, 20009, 10040, 10147, 10110, 10105, 20398, 20469,
+    20203, 20254, 30402, 30013, 40200, 30689, 20115, 20356, 20345, 20466,
+    40033, 10153, 30153, 30012, 40340, 30140, 40214, 10129, 30211, 20078,
+    30109, 30013, 20116, 20243, 20085, 40271,
+]   # [OFFICIAL] 76 entries, 72 unique (20153, 20167, 20203, 30013 appear 2x)
+
+VAL_PATCH_IDS = [
+    10127, 40438, 30643, 30619, 30436, 10306, 10127, 30226, 40027, 40279,
+    40085, 40455, 40426, 40444, 40298, 40231, 20498, 40298, 20149, 20315,
+    20340, 20618, 20412, 20231, 40006, 40138, 40186, 10087, 40430, 30194,
+    10247, 40383, 20364, 20128, 20060, 20118, 40001, 20080, 40063, 30000,
+    40063, 40000, 40348, 10021, 40001, 20023, 30000, 20441, 20235, 20344,
+    20297, 20576, 30014, 30275, 30298, 30083, 20206, 20443, 20423, 20380,
+    30064, 30084, 30145, 10107, 10225, 40558, 10383, 20131, 30010, 20022,
+    30295, 20042, 20031, 40046, 20358, 30142,
+]   # [OFFICIAL] 76 entries, 71 unique (10127, 40298, 40001, 40063, 30000 2x)
+
+# ─── Protocol: test split ───────────────────────────────────────────────────
+TEST_FOLDS      = [4]           # [OFFICIAL] 482 patches, spatially disjoint
+                                # from folds 1/2/5 with a 1 km buffer
+TEST_FULL_PATCH = True          # [OFFICIAL] test_STCLN.py:55 does
+                                # `split = W // 1` -> the whole 128x128 patch
+                                # is evaluated, NOT 32x32 crops.
+                                #   482 patches ~ 482 x 16 = 7,712 crop-equiv
+
+# ─── Pretrain hyperparameters ───────────────────────────────────────────────
+PRE_EPOCHS    = 100             # [OFFICIAL]
+PRE_BATCH     = 4               # [OFFICIAL] PATCHES per batch, not crops. The
+                                # inner 4x4 loop then does 16 separate
+                                # optimizer steps on 4 crops each. Raising this
+                                # changes the optimization trajectory, not just
+                                # memory — do not tune it for the headline run.
+PRE_LR        = 1e-4            # [OFFICIAL] flat, no schedule
+PRE_WD        = 0.0             # [OFFICIAL] AdamW with wd=0 reduces to Adam
+                                # exactly. Set to 0.0 (from 0.01) so the only
+                                # variable vs A_linear is the temporal encoder.
+PRE_CLIP      = 5.0             # [OFFICIAL]
+MASK_RATIO    = 0.4             # [OFFICIAL]
+NDVI_THRESH   = 0.2             # [OFFICIAL]
+CLOUD_GATE    = 0.9             # [OFFICIAL] STCLN.py:200 `mask[clusterLmean
+                                # <= 0.9] = 1`. clusterLmean averages the NDVI
+                                # indicator over H and W, so this is a PER-FRAME
+                                # gate: a timestep whose frame is <=90%
+                                # vegetated is left ENTIRELY visible. It is NOT
+                                # a per-pixel vegetation filter. Measured on 20
+                                # fold-5 patches: fires on 90.6% of frames,
+                                # leaving 96.2% of all values visible.
+PRE_SAVE_EVERY = 20             # [TSRDA] keep a numbered milestone every N
+                                # epochs (0, 19, 39, 59, 79, 99 at N=20).
+                                # Independent of this, `latest.tar` is written
+                                # EVERY epoch with optimizer + scaler + RNG
+                                # state, so a crash costs at most one epoch
+                                # (~26 min) rather than up to N (~8.7 h).
+DEEP_SUP      = False           # [OFFICIAL] the deep-supervision term is
+                                # commented out upstream
+                                # (pretraining_STCLN.py:141
+                                # `l = loss(output, target)#+loss(x2,target)`).
+
+# ─── Finetune hyperparameters ───────────────────────────────────────────────
+FT_EPOCHS     = 100             # [OFFICIAL]
+FT_BATCH      = 2               # [OFFICIAL] PATCHES per batch (x2 crop-steps)
+FT_LR         = 1e-4            # [OFFICIAL] flat Adam, NO scheduler
+FT_WD         = 0.0             # [OFFICIAL] AdamW with wd=0 == Adam
+FT_AUGMENT    = False           # [OFFICIAL] no augmentation in finetuning_STCLN
+FT_SCHEDULER  = None            # [OFFICIAL] flat LR, no schedule.
+FT_PATIENCE   = 0               # [OFFICIAL] no early stopping (grep: 0 matches
+                                # in the reference). 0 disables it entirely.
+                                # MUST stay 0: the primary report is the
+                                # FIXED-EPOCH ep99 number. Early stopping on
+                                # 152 val crops manufactured a 147x variance
+                                # effect that vanished at fixed epoch, and if
+                                # it fires at ep58 there is no ep99 checkpoint
+                                # to compare against A_linear at all.
+
+# ─── Evaluation ─────────────────────────────────────────────────────────────
+EVAL_BATCH    = int(os.environ.get("EVAL_BATCH", 2))   # 2 fits a 16 GB T4 (9.5 GB peak measured)
+                                # [HW] official test_STCLN.py uses 1. Full-patch
+                                # inference is numerically identical at any
+                                # batch size (nothing in eval mode depends on
+                                # the batch), so this is a pure memory/speed
+                                # knob with no effect on the reported metrics.
+                                # MEASURED for T-SRDA on this 23.6 GB L4 against
+                                # the worst case (fold 4 runs to T=61):
+                                #   batch 1 ->  5.05 GB peak   482 batches
+                                #   batch 2 ->  9.50 GB peak   241 batches
+                                #   batch 4 -> 16.86 GB peak   121 batches
+                                # Default 4 gives the protocol's 121 batches and
+                                # fits with ~6.7 GB spare ON A FREE CARD.
+                                # asr-gpu.service is systemd-`enabled` on this
+                                # box and takes ~8 GB when it comes back after a
+                                # reboot, leaving ~15.6 GB — under batch 4. If
+                                # eval OOMs, just rerun with EVAL_BATCH=2; the
+                                # numbers are unchanged.
+EVAL_TTA      = False           # [OFFICIAL] test_STCLN.py has no TTA
+
+# ─── PASTIS class nomenclature ──────────────────────────────────────────────
+# THE single source of truth for this repo. The list that shipped in the
+# original tsrda scripts was wrong for 12 of 20 classes (it invented
+# "Protein peas", "Flax", "Sugar beet", "Vineyards", "Nuts" and mislabelled
+# 13 as Soy / 17 as Potatoes). Verified identical to PhenoProto-SSL's
+# splits.PASTIS_CLASSES, which preflight.py asserts against the official
+# PASTIS benchmark list. Never redefine this locally in another module.
+PASTIS_CLASSES = {
+    0:  "Background",
+    1:  "Meadow",
+    2:  "Soft winter wheat",
+    3:  "Corn",
+    4:  "Winter barley",
+    5:  "Winter rapeseed",
+    6:  "Spring barley",
+    7:  "Sunflower",
+    8:  "Grapevine",
+    9:  "Beet",
+    10: "Winter triticale",
+    11: "Winter durum wheat",
+    12: "Fruits, vegetables, flowers",
+    13: "Potatoes",
+    14: "Leguminous fodder",
+    15: "Soybeans",
+    16: "Orchard",
+    17: "Mixed cereal",
+    18: "Sorghum",
+    19: "Void label",
+}

main_method/code/dataset.py

@@ -0,0 +1,203 @@
+"""
+PASTIS dataset loader for T-SRDA — OFFICIAL STCLN protocol.
+
+Each dataset item is ONE FULL 128x128 patch. Sub-cropping happens in the
+training loop, not here, exactly as the reference implementation does it:
+
+  pretrain  (pretraining_STCLN.py:123)  for i in range(4): for j in range(4)
+  finetune  (finetuning_STCLN.py:185)   for i,j in [[0,0],[1,1]]
+  test      (test_STCLN.py:52)          for i in range(1)  -> full patch
+
+Keeping the crop schedule in the loop is what makes the step counts line up
+with the paper: each (i, j) is a SEPARATE optimizer step, so pretrain does
+124 batches x 16 crops = 1,984 steps/epoch, not 496 steps.
+
+Split builders:
+  patches_in_folds([5])   -> 496 pretrain patch IDs
+  train_patch_ids()       ->  76 IDs (fold 1, duplicates kept)
+  val_patch_ids()         ->  76 IDs (fold 2, duplicates kept)
+  test_patch_ids()        -> 482 IDs (fold 4)
+"""
+import json
+from datetime import datetime
+import numpy as np
+import torch
+from torch.utils.data import Dataset
+
+import config as C
+
+REF_DATE = datetime(*map(int, C.REF_DATE_STR.split("-")))
+
+
+# ---------------------------------------------------------------------------
+# Metadata + normalisation loaders (cached at module level)
+# ---------------------------------------------------------------------------
+def _date_to_days(date_int):
+    s = str(int(date_int))
+    y, m, d = int(s[:4]), int(s[4:6]), int(s[6:8])
+    return (datetime(y, m, d) - REF_DATE).days
+
+
+def _load_meta():
+    raw = json.load(open(C.META_PATH))
+    info = {}
+    for feat in raw["features"]:
+        p    = feat["properties"]
+        pid  = int(p.get("ID_PATCH", p.get("id_patch", -1)))
+        fold = int(p.get("Fold",     p.get("fold",     0)))
+        dates_dict = p.get("dates-S2", {})
+        sorted_dates = sorted(dates_dict.items(), key=lambda x: int(x[0]))
+        days = [_date_to_days(v) for _, v in sorted_dates]
+        info[pid] = {"fold": fold, "dates": days}
+    return info
+
+
+def _load_norm():
+    """Mean/std averaged across all folds; differs from fold-selected upstream normalization."""
+    raw = json.load(open(C.NORM_PATH))
+    if "mean" in raw:
+        return (np.array(raw["mean"], dtype=np.float32),
+                np.array(raw["std"],  dtype=np.float32))
+    fold_keys = [k for k in raw if k.startswith("Fold_")]
+    means = np.array([raw[k]["mean"] for k in fold_keys], dtype=np.float32)
+    stds  = np.array([raw[k]["std"]  for k in fold_keys], dtype=np.float32)
+    return means.mean(axis=0), stds.mean(axis=0)
+
+
+_META = None
+_NORM = None
+
+
+def get_meta():
+    global _META
+    if _META is None:
+        _META = _load_meta()
+    return _META
+
+
+def get_norm():
+    global _NORM
+    if _NORM is None:
+        _NORM = _load_norm()
+    return _NORM
+
+
+# ---------------------------------------------------------------------------
+# Split builders (official protocol)
+# ---------------------------------------------------------------------------
+def patches_in_folds(folds):
+    """Sorted patch IDs belonging to the given folds."""
+    meta = get_meta()
+    return sorted(p for p in meta if meta[p]["fold"] in folds)
+
+
+def pretrain_patch_ids():
+    """496 fold-5 patch IDs — the unlabelled pretraining pool."""
+    return patches_in_folds(C.PRETRAIN_FOLDS)
+
+
+def train_patch_ids():
+    """76 hardcoded fold-1 IDs. Duplicates are intentional and preserved."""
+    return list(C.TRAIN_PATCH_IDS)
+
+
+def val_patch_ids():
+    """76 hardcoded fold-2 IDs. Duplicates are intentional and preserved."""
+    return list(C.VAL_PATCH_IDS)
+
+
+def test_patch_ids():
+    """482 fold-4 patch IDs — evaluated as full 128x128 patches."""
+    return patches_in_folds(C.TEST_FOLDS)
+
+
+# ---------------------------------------------------------------------------
+# Patch-level Dataset
+# ---------------------------------------------------------------------------
+class PASTISPatchDataset(Dataset):
+    """Returns ONE full 128x128 patch per __getitem__.
+
+    __getitem__ -> (x, pos, days), y
+        x     (T, 10, 128, 128) float32, per-band normalised
+        pos   (T,)  what the model is fed: arange(T) if USE_INDEX_POSITIONS
+                    else real day offsets
+        days  (T,)  real day offsets from REF_DATE, always — for analysis
+        y     (128, 128) int64 semantic labels
+    """
+
+    def __init__(self, patch_ids, load_target=True):
+        self.ids = list(patch_ids)          # duplicates preserved on purpose
+        self.meta = get_meta()
+        self.norm_mean, self.norm_std = get_norm()
+        self.load_target = load_target
+
+    def __len__(self):
+        return len(self.ids)
+
+    def __getitem__(self, idx):
+        pid = self.ids[idx]
+
+        x = np.load(C.DATA_S2_DIR / f"S2_{pid}.npy").astype(np.float32)
+        x = (x - self.norm_mean[None, :, None, None]) \
+            / (self.norm_std[None, :, None, None] + 1e-8)
+
+        T = x.shape[0]
+        days = np.asarray(self.meta[pid]["dates"][:T], dtype=np.float32)
+        if days.shape[0] < T:
+            days = np.pad(days, (0, T - days.shape[0]))
+
+        pos = np.arange(T, dtype=np.float32) if C.USE_INDEX_POSITIONS else days
+
+        if self.load_target:
+            target = np.load(C.ANNOT_DIR / f"TARGET_{pid}.npy")
+            y = torch.from_numpy(target[0].astype(np.int64))
+        else:
+            y = torch.zeros(C.PATCH_SIZE, C.PATCH_SIZE, dtype=torch.long)
+
+        return (torch.from_numpy(x),
+                torch.from_numpy(pos),
+                torch.from_numpy(days)), y
+
+
+# ---------------------------------------------------------------------------
+# Collate (pads variable T to the batch max — official pad_collate behaviour)
+# ---------------------------------------------------------------------------
+def pad_collate(batch, pad_value=0.0):
+    xs, ps, ds, ys = [], [], [], []
+    for (x, p, d), y in batch:
+        xs.append(x); ps.append(p); ds.append(d); ys.append(y)
+
+    max_T = max(x.shape[0] for x in xs)
+
+    def pad(t, v=0.0):
+        if t.shape[0] == max_T:
+            return t
+        z = torch.full((max_T - t.shape[0], *t.shape[1:]), v, dtype=t.dtype)
+        return torch.cat([t, z], dim=0)
+
+    return ((torch.stack([pad(x, pad_value) for x in xs]),
+             torch.stack([pad(p) for p in ps]),
+             torch.stack([pad(d) for d in ds])),
+            torch.stack(ys))
+
+
+# Backwards-compatible alias — the train scripts pass collate_fn=collate_fn.
+collate_fn = pad_collate
+
+
+# ---------------------------------------------------------------------------
+# Crop helper — the inner (i, j) loop of the official training scripts
+# ---------------------------------------------------------------------------
+def crop_ij(x, y, i, j, grid=None):
+    """Slice crop (i, j) out of a batch of full patches.
+
+      x: (B, T, C, H, W)   y: (B, H, W) or None
+      grid: 4 -> 32x32 crops (train/finetune); 1 -> the whole patch (test)
+
+    Mirrors `split = input.shape[-1] // grid` in the reference scripts.
+    """
+    grid = C.PRETRAIN_CROP_GRID if grid is None else grid
+    s = x.shape[-1] // grid
+    xc = x[:, :, :, i * s:(i + 1) * s, j * s:(j + 1) * s]
+    yc = None if y is None else y[:, i * s:(i + 1) * s, j * s:(j + 1) * s]
+    return xc, yc

main_method/code/evaluate.py

@@ -0,0 +1,88 @@
+"""Evaluate complete final bundles without changing the scored input protocol."""
+import argparse,hashlib,json,time
+from pathlib import Path
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+import config as C
+from dataset import PASTISPatchDataset,val_patch_ids,test_patch_ids,pad_collate,crop_ij
+from model import UTAE_ASPP,UTAEClassificationDual
+from training_feature_clusters import DepthCollector,probability,metrics_cm
+from temporal_cnn import TemporalCNN,AttentionCNN
+
+MAIN=Path(__file__).resolve().parents[1]
+
+def digest(path):
+    h=hashlib.sha256()
+    with path.open('rb') as f:
+        for part in iter(lambda:f.read(8*1024*1024),b''):h.update(part)
+    return h.hexdigest()
+
+def manifest(name):
+    folder=MAIN/'configurations'/f'32X32_{name}_seed3407'
+    return json.loads((folder/'manifest.json').read_text()),folder
+
+def load_state(path):
+    return torch.load(path,map_location='cpu',weights_only=False)
+
+def load_models(names,device,verify=True):
+    specs={n:manifest(n)[0] for n in names};shared=MAIN/'checkpoints/shared'
+    for spec in specs.values():
+        if verify:
+            for key in ['sam_checkpoint','feature_cluster_checkpoint','original_cnn_checkpoint','addition_checkpoint']:
+                file=spec[key]
+                if digest(shared/file)!=spec['sha256'][file]:raise RuntimeError('Checkpoint hash mismatch: '+file)
+    sam=UTAEClassificationDual(UTAE_ASPP(n_channels=C.N_CHANNELS,d_model=C.D_MODEL,n_heads=C.N_HEADS),d_model=C.D_MODEL,num_classes=C.N_CLASSES)
+    first=next(iter(specs.values()));sam.load_state_dict(load_state(shared/first['sam_checkpoint'])['model_state_dict'],strict=True)
+    sam=sam.to(device).eval().requires_grad_(False)
+    clusters=load_state(shared/first['feature_cluster_checkpoint'])
+    old=TemporalCNN(18);old.load_state_dict(load_state(shared/first['original_cnn_checkpoint'])['state'],strict=True);old=old.to(device).eval().requires_grad_(False)
+    additions={}
+    for name,spec in specs.items():
+        model=TemporalCNN(18) if spec['addition_kind']=='cnn_control' else AttentionCNN(18)
+        ck=load_state(shared/spec['addition_checkpoint']);assert ck['seed']==3407 and ck['classes']==list(range(1,19))
+        model.load_state_dict(ck['state'],strict=True);additions[name]=model.to(device).eval().requires_grad_(False)
+    return specs,sam,clusters,old,additions
+
+@torch.inference_mode()
+def main():
+    ap=argparse.ArgumentParser()
+    ap.add_argument('--configuration',choices=['recommended_validation','highest_observed_test','both'],default='recommended_validation')
+    ap.add_argument('--split',choices=['val','test'],default='test')
+    ap.add_argument('--output',type=Path,default=MAIN/'evaluation_results.json')
+    ap.add_argument('--skip_hash_check',action='store_true');args=ap.parse_args()
+    if not torch.cuda.is_available():raise RuntimeError('The scored inference recipe requires a working CUDA runtime; CPU loading is checked separately.')
+    torch.set_num_threads(4);torch.manual_seed(3407);torch.backends.cuda.matmul.allow_tf32=True;torch.backends.cudnn.allow_tf32=True
+    names=['recommended_validation','highest_observed_test'] if args.configuration=='both' else [args.configuration]
+    specs,sam,clusters,old,additions=load_models(names,'cuda',not args.skip_hash_check)
+    collector=DepthCollector(sam.utae);mean,std=clusters['mean'].cuda(),clusters['std'].cuda()
+    state={k:v.cuda() for k,v in clusters['state'].items()} if clusters['kind']=='linear' else clusters['state'].cuda()
+    ids=val_patch_ids() if args.split=='val' else test_patch_ids();batch=2 if args.split=='val' else 1
+    dl=DataLoader(PASTISPatchDataset(ids),batch_size=batch,shuffle=False,num_workers=2,pin_memory=True,collate_fn=pad_collate)
+    matrices={name:np.zeros((20,20),np.int64) for name in names};started=time.monotonic()
+    try:
+        for bi,((x,pos,_),y) in enumerate(dl):
+            x,pos=x.cuda(),pos.cuda()
+            for i,j in C.FT_CROP_IJ if args.split=='val' else [(0,0)]:
+                xc,yc=crop_ij(x,y,i,j,4 if args.split=='val' else 1);collector.begin(xc,pos)
+                with torch.autocast('cuda',dtype=torch.float16):
+                    output=sam(xc,pos);original_logits=old(xc,pos)
+                    additional_logits={name:net(xc,pos) for name,net in additions.items()}
+                features=collector.end();spatial=output['refined_logits'].float().softmax(1)
+                pp=probability(features,clusters['depth'],mean,std,clusters['kind'],state)
+                b,_,h,w=spatial.shape;cluster_probs=torch.from_numpy(pp).cuda().reshape(b,h,w,20).permute(0,3,1,2)
+                feature_blend=.5*spatial+.5*cluster_probs
+                original_probs=torch.zeros_like(spatial);original_probs[:,1:19]=original_logits.float().softmax(1)
+                reference=.75*feature_blend+.25*original_probs
+                gt=yc.numpy().ravel();valid=(gt>0)&(gt<19)
+                for name,spec in specs.items():
+                    probs=torch.zeros_like(spatial);probs[:,1:19]=additional_logits[name].float().softmax(1)
+                    alpha=spec['addition_alpha'];prediction=((1-alpha)*reference+alpha*probs).argmax(1).cpu().numpy().ravel()
+                    matrices[name]+=np.bincount(20*gt[valid]+prediction[valid],minlength=400).reshape(20,20)
+            if bi%50==0:print(args.split,bi,len(dl),flush=True)
+    finally:collector.close()
+    result={'split':args.split,'patch_entries':len(ids),'batch_size':batch,'seed':3407,'seconds':time.monotonic()-started,'configurations':{name:{'metrics':metrics_cm(matrices[name]),'manifest':specs[name]} for name in names}}
+    args.output.parent.mkdir(parents=True,exist_ok=True);args.output.write_text(json.dumps(result,indent=2))
+    for name,item in result['configurations'].items():print(name,'mIoU',item['metrics']['miou'],flush=True)
+
+if __name__=='__main__':main()

main_method/code/losses.py

@@ -0,0 +1,94 @@
+"""
+Lovász-Softmax loss — NaN-safe version for small-batch training.
+
+Fixes over v1:
+  - eps guard on union denominator (prevents /0 on rare classes)
+  - support for multiple ignore indices (background + void)
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+def lovasz_grad(gt_sorted):
+    """Gradient of Lovász extension w.r.t. sorted errors."""
+    p = len(gt_sorted)
+    gts = gt_sorted.sum()
+    intersection = gts - gt_sorted.float().cumsum(0)
+    union        = gts + (1.0 - gt_sorted).float().cumsum(0)
+    jaccard      = 1.0 - intersection / (union + 1e-6)   # eps guard
+    if p > 1:
+        jaccard[1:p] = jaccard[1:p] - jaccard[0:-1]
+    return jaccard
+
+
+def lovasz_softmax_flat(probas, labels, classes="present"):
+    """
+    Multi-class Lovász-Softmax on flattened tensors.
+      probas: (N, C) softmax probabilities
+      labels: (N,)   ground truth indices
+    """
+    if probas.numel() == 0:
+        return probas * 0.0
+
+    C = probas.shape[1]
+
+    if classes == "all":
+        class_list = list(range(C))
+    elif classes == "present":
+        class_list = torch.unique(labels).tolist()
+    else:
+        class_list = list(classes)
+
+    losses = []
+    for c in class_list:
+        fg = (labels == c).float()
+        if fg.sum() == 0:
+            continue
+        class_pred = probas[:, c]
+        errors = (fg - class_pred).abs()
+        errors_sorted, perm = torch.sort(errors, dim=0, descending=True)
+        fg_sorted = fg[perm.data]
+        grad = lovasz_grad(fg_sorted)
+        loss_c = torch.dot(errors_sorted, grad)
+        if torch.isfinite(loss_c):
+            losses.append(loss_c)
+
+    if not losses:
+        return probas.sum() * 0.0
+
+    return sum(losses) / len(losses)
+
+
+class LovaszSoftmaxLoss(nn.Module):
+    """
+    Lovász-Softmax for 2D segmentation.
+      logits:  (B, C, H, W)
+      targets: (B, H, W) long
+      ignore_indices: list of class indices to exclude (e.g. [0, 19])
+    """
+    def __init__(self, ignore_indices=None, classes="present"):
+        super().__init__()
+        self.ignore_indices = ignore_indices or []
+        self.classes = classes
+
+    def forward(self, logits, targets):
+        probas = F.softmax(logits, dim=1)
+        B, C, H, W = probas.shape
+        probas_flat  = probas.permute(0, 2, 3, 1).contiguous().view(-1, C)
+        targets_flat = targets.contiguous().view(-1)
+
+        # Mask out all ignore indices
+        if self.ignore_indices:
+            valid = torch.ones(targets_flat.shape[0], dtype=torch.bool,
+                               device=targets_flat.device)
+            for idx in self.ignore_indices:
+                valid &= (targets_flat != idx)
+            probas_flat  = probas_flat[valid]
+            targets_flat = targets_flat[valid]
+
+        if probas_flat.numel() == 0:
+            return logits.sum() * 0.0
+
+        loss = lovasz_softmax_flat(probas_flat, targets_flat, classes=self.classes)
+        return torch.nan_to_num(loss, nan=0.0)

main_method/code/model.py

@@ -0,0 +1,372 @@
+"""
+T-SRDA model — AD-STCLN backbone with PDAViT-style Temporal
+Spatial-Reduction Dual-Attention (Zhou et al., Neurocomputing 2026)
+replacing the DaViT/Swin temporal encoder.
+
+Pipeline (identical I/O contract to the det experiment):
+
+  UTAE_ASPP                encoder:  (B,T,C,H,W), (B,T) days
+                              -> out (B,H,W,T,D), x2 (B*T,D,H,W)
+  UTAEPrediction           pretrain wrapper: NDVI-aware masking + MSE recon
+                              -> (recon, recon2, target, mask)  [1=visible]
+  UTAEClassificationDual   finetune wrapper: STA temporal collapse +
+                              dual decoder (semantic + boundary) + gated
+                              refinement -> dict(sem_logits, bnd_logits,
+                              refined_logits)
+  compute_boundary_target  morphological-gradient boundary GT (B,H,W)
+
+Temporal encoder change (the ONLY architectural difference vs det/DaViT):
+  TemporalDaViTEncoder -> TemporalSRDAEncoder (temporal_srda.py)
+    KV path: Linear d->d/R, unfold R steps -> (T/R, d), first SA (K-V
+    self-checking); second SA: full-T queries x reduced KV -> global
+    temporal receptive field per layer.
+
+Checkpointing: chunk-level only (TEMPORAL_CHUNK sequences per checkpointed
+chunk). The temporal encoder has NO internal checkpointing — layer-level +
+chunk-level double-checkpointing wasted ~30% backward compute in the DaViT
+version.
+"""
+import math
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
+
+import config as C
+from temporal_srda import TemporalSRDAEncoder
+
+TEMPORAL_CHUNK = 1024      # per-pixel sequences per checkpointed chunk (train)
+EVAL_TEMPORAL_CHUNK = 4096   # larger in eval — no checkpointing to pay for
+SPATIAL_CHUNK = 32           # frames per spatial-encoder chunk in eval
+#
+# Eval-mode chunking exists for the official test protocol: test_STCLN.py feeds
+# WHOLE 128x128 patches, so one batch-4 sample is 4*61 = 244 frames and
+# 4*128*128 = 65,536 per-pixel temporal sequences. Unchunked, the ASPP concat
+# alone (1024 ch at 128x128) would need ~16 GB. Training is unaffected: at
+# 32x32 crops the chunk paths below are never entered.
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 1. Positional encoding over real acquisition days
+# ═══════════════════════════════════════════════════════════════════════════
+class PositionalEncoder(nn.Module):
+    """Sinusoidal PE over day offsets. days: (..., T) -> (..., T, d)."""
+
+    def __init__(self, d_model, T=1000):
+        super().__init__()
+        self.d_model = d_model
+        denom = torch.pow(
+            T, 2.0 * (torch.arange(d_model).div(2, rounding_mode="floor"))
+               / d_model)
+        self.register_buffer("denom", denom, persistent=False)
+
+    def forward(self, days):
+        pe = days[..., None] / self.denom            # (..., T, d)
+        pe = torch.stack([torch.sin(pe[..., 0::2]),
+                          torch.cos(pe[..., 1::2])], dim=-1)
+        return pe.flatten(-2)                        # interleave sin/cos
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 2. Atrous spatial encoder: (B*T, C_in, H, W) -> (B*T, D, H, W)
+# ═══════════════════════════════════════════════════════════════════════════
+class SEBlock(nn.Module):
+    def __init__(self, channels, reduction=8):
+        super().__init__()
+        self.fc = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(channels, channels // reduction, 1),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(channels // reduction, channels, 1),
+            nn.Sigmoid(),
+        )
+
+    def forward(self, x):
+        return x * self.fc(x)
+
+
+class ASPP(nn.Module):
+    """Atrous spatial pyramid pooling neck at full 32x32 resolution."""
+
+    def __init__(self, in_ch, out_ch, dilations=(1, 2, 4)):
+        super().__init__()
+        self.branches = nn.ModuleList([
+            nn.Sequential(
+                nn.Conv2d(in_ch, out_ch, 3, padding=d, dilation=d, bias=False),
+                nn.BatchNorm2d(out_ch),
+                nn.ReLU(inplace=True))
+            for d in dilations
+        ])
+        self.pool = nn.Sequential(
+            nn.AdaptiveAvgPool2d(1),
+            nn.Conv2d(in_ch, out_ch, 1, bias=False),
+            nn.ReLU(inplace=True),
+        )
+        self.project = nn.Sequential(
+            nn.Conv2d(out_ch * (len(dilations) + 1), out_ch, 1, bias=False),
+            nn.BatchNorm2d(out_ch),
+            nn.ReLU(inplace=True),
+        )
+
+    def forward(self, x):
+        feats = [b(x) for b in self.branches]
+        gp = self.pool(x)
+        feats.append(F.interpolate(gp, size=x.shape[-2:], mode="nearest"))
+        return self.project(torch.cat(feats, dim=1))
+
+
+class AtrousSpatialEncoder(nn.Module):
+    """Dilated conv stem + ASPP + SE. Keeps full spatial resolution."""
+
+    def __init__(self, in_channels=10, d_model=256):
+        super().__init__()
+        mid = d_model // 4                                    # 64
+        self.stem = nn.Sequential(
+            nn.Conv2d(in_channels, mid, 3, padding=1, bias=False),
+            nn.BatchNorm2d(mid),
+            nn.ReLU(inplace=True),
+            nn.Conv2d(mid, mid, 3, padding=2, dilation=2, bias=False),
+            nn.BatchNorm2d(mid),
+            nn.ReLU(inplace=True),
+        )
+        self.aspp = ASPP(mid, d_model, dilations=(1, 2, 4))
+        self.se = SEBlock(d_model)
+
+    def forward(self, x):                                     # (N, C, H, W)
+        return self.se(self.aspp(self.stem(x)))               # (N, D, H, W)
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 3. Encoder wrapper: spatial per-frame + T-SRDA temporal per-pixel
+# ═══════════════════════════════════════════════════════════════════════════
+class UTAE_ASPP(nn.Module):
+    """
+    forward(x, pos):
+      x   : (B, T, C, H, W)  normalized S2 crops
+      pos : (B, T)           day offsets (0 on padded steps)
+    returns:
+      out : (B, H, W, T, D)  temporally contextualized per-pixel features
+      x2  : (B*T, D, H, W)   spatial features (deep-supervision recon path)
+    """
+
+    def __init__(self, n_channels=10, d_model=256, n_heads=8,
+                 T_pad=48, windows=None, shifts=None, **kwargs):
+        super().__init__()
+        # T_pad / windows / shifts are absorbed for constructor compatibility
+        # with pretrain.py / finetune.py / evaluate.py; T-SRDA ignores them
+        # (the encoder self-pads T to a multiple of max(R_SCHEDULE)).
+        self.d_model = d_model
+        self.spatial_encoder = AtrousSpatialEncoder(n_channels, d_model)
+        self.pos_encoder = PositionalEncoder(d_model)
+        self.temporal_encoder = TemporalSRDAEncoder(
+            d_model=d_model, n_heads=n_heads, R_schedule=C.R_SCHEDULE)
+
+    def _run_temporal_chunk(self, x_chunk, pos_chunk):
+        return self.temporal_encoder(x_chunk, pos_chunk)
+
+    def _encode_spatial(self, frames):
+        """(N, C, H, W) -> (N, D, H, W). Chunked in eval to cap the ASPP peak."""
+        N = frames.shape[0]
+        if self.training or N <= SPATIAL_CHUNK:
+            return self.spatial_encoder(frames)
+        return torch.cat([self.spatial_encoder(frames[s:s + SPATIAL_CHUNK])
+                          for s in range(0, N, SPATIAL_CHUNK)], dim=0)
+
+    def forward(self, x, pos):
+        B, T, Cc, H, W = x.shape
+
+        # ---- spatial encoding, frame by frame ------------------------------
+        x2 = self._encode_spatial(x.reshape(B * T, Cc, H, W))   # (B*T,D,H,W)
+        D = x2.shape[1]
+
+        # ---- to per-pixel temporal sequences -------------------------------
+        x_te = (x2.reshape(B, T, D, H, W)
+                  .permute(0, 3, 4, 1, 2)                       # (B,H,W,T,D)
+                  .reshape(B * H * W, T, D))
+
+        pe = self.pos_encoder(pos)                              # (B, T, D)
+        pos_exp = (pe[:, None, None, :, :]
+                   .expand(B, H, W, T, D)
+                   .reshape(B * H * W, T, D))
+
+        # ---- temporal encoder, chunked + checkpointed in training ----------
+        N = x_te.shape[0]
+        if self.training and N > TEMPORAL_CHUNK:
+            outs = []
+            for s in range(0, N, TEMPORAL_CHUNK):
+                e = min(s + TEMPORAL_CHUNK, N)
+                outs.append(checkpoint(self._run_temporal_chunk,
+                                       x_te[s:e], pos_exp[s:e],
+                                       use_reentrant=False))
+            out = torch.cat(outs, dim=0)
+        elif not self.training and N > EVAL_TEMPORAL_CHUNK:
+            outs = []
+            for s in range(0, N, EVAL_TEMPORAL_CHUNK):
+                e = min(s + EVAL_TEMPORAL_CHUNK, N)
+                outs.append(self.temporal_encoder(x_te[s:e], pos_exp[s:e]))
+            out = torch.cat(outs, dim=0)
+        else:
+            out = self.temporal_encoder(x_te, pos_exp)          # (B*H*W,T,D)
+
+        out = out.reshape(B, H, W, T, D)
+        return out, x2
+
+
+# ═══════════════════════════════════���═══════════════════════════════════════
+# 4. Pretrain wrapper: NDVI-aware masking + MSE reconstruction
+#    (logic recovered from the det pipeline — mask: 1=visible, 0=masked)
+# ═══════════════════════════════════════════════════════════════════════════
+class UTAEPrediction(nn.Module):
+    def __init__(self, encoder, n_channels=10, d_model=256, mask_ratio=0.4):
+        super().__init__()
+        self.utae = encoder
+        self.linear = nn.Linear(d_model, n_channels)    # main reconstruction
+        self.midlinear = nn.Linear(d_model, n_channels)  # deep supervision
+        self.mask_ratio = mask_ratio
+        self.mask_token = nn.Parameter(torch.zeros(1))
+
+    def forward(self, x, pos):
+        """Official STCLN masking — STCLN.py:193-202, bit-for-bit.
+
+        The NDVI indicator is per-timestep-per-pixel, but `clusterLmean`
+        averages it over H and W, so the gate is PER FRAME: a timestep whose
+        frame is <= CLOUD_GATE vegetated is left ENTIRELY visible. This is
+        NOT a per-pixel vegetation filter, and getting that wrong changes the
+        pretext task (measured: the official gate leaves 96.2% of all values
+        visible, a per-pixel version leaves 82.3%).
+        """
+        # x: (B, T, C, H, W)   pos: (B, T)
+        target = x.clone()
+        B, T, Cc, H, W = x.shape
+
+        with torch.no_grad():
+            # NDVI indicator on normalized bands: (NIR b6 - Red b2)/(Red + NIR)
+            ndvi = (x[:, :, 6] - x[:, :, 2]) / (x[:, :, 2] + x[:, :, 6] + 1e-20)
+            cluster = ndvi.gt(C.NDVI_THRESH).float()          # (B, T, H, W)
+
+            # F.dropout: kept -> scaled ones, dropped -> zeros; * (1-p) undoes
+            # the scaling so the mask is exactly {0, 1}. 1 = visible.
+            mask = torch.ones(B, T, H, W, device=x.device)
+            mask = F.dropout(mask, p=self.mask_ratio, training=True) \
+                   * (1.0 - self.mask_ratio)
+            mask_4d = mask[:, :, None].repeat(1, 1, Cc, 1, 1)
+
+            # per-FRAME vegetation fraction -> exempt whole frames from masking
+            frame_veg = cluster.mean(dim=[2, 3])              # (B, T)
+            exempt = (frame_veg <= C.CLOUD_GATE)[:, :, None, None, None]
+            mask_4d = torch.where(exempt, torch.ones_like(mask_4d), mask_4d)
+
+        x_masked = x * mask_4d + self.mask_token * (1.0 - mask_4d)
+
+        out, x2 = self.utae(x_masked, pos)      # (B,H,W,T,D), (B*T,D,H,W)
+
+        recon = self.linear(out).permute(0, 3, 4, 1, 2)          # (B,T,C,H,W)
+        recon2 = (self.midlinear(x2.permute(0, 2, 3, 1))
+                  .permute(0, 3, 1, 2)
+                  .reshape(B, T, Cc, H, W))
+        return recon, recon2, target, mask_4d
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 5. Finetune wrapper: STA temporal collapse + dual decoder + gated refine
+# ═══════════════════════════════════════════════════════════════════════════
+class STA(nn.Module):
+    """Spatio-temporal aggregation: attention-pool T, refine spatially.
+    (Reconstruction of base STCLN's conv1/conv2/conv3/l collapse module.)"""
+
+    def __init__(self, d_model=256):
+        super().__init__()
+        self.l = nn.Linear(d_model, 1)                 # temporal attn scores
+        self.conv1 = nn.Sequential(
+            nn.Conv2d(d_model, d_model, 3, padding=1, bias=False),
+            nn.BatchNorm2d(d_model), nn.ReLU(inplace=True))
+        self.conv2 = nn.Sequential(
+            nn.Conv2d(d_model, d_model, 3, padding=1, bias=False),
+            nn.BatchNorm2d(d_model), nn.ReLU(inplace=True))
+        self.conv3 = nn.Sequential(
+            nn.Conv2d(d_model, d_model, 1, bias=False),
+            nn.BatchNorm2d(d_model), nn.ReLU(inplace=True))
+
+    def forward(self, feats):                          # (B, H, W, T, D)
+        w = self.l(feats).softmax(dim=3)               # (B, H, W, T, 1)
+        f = (feats * w).sum(dim=3)                     # (B, H, W, D)
+        f = f.permute(0, 3, 1, 2).contiguous()         # (B, D, H, W)
+        f = f + self.conv2(self.conv1(f))              # residual refine
+        return self.conv3(f)
+
+
+class SemanticDecoder(nn.Module):
+    def __init__(self, d_model=256, num_classes=20):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(d_model, d_model // 2, 3, padding=1, bias=False),
+            nn.BatchNorm2d(d_model // 2), nn.ReLU(inplace=True),
+            nn.Conv2d(d_model // 2, num_classes, 1))
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class BoundaryDecoder(nn.Module):
+    def __init__(self, d_model=256):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(d_model, d_model // 4, 3, padding=1, bias=False),
+            nn.BatchNorm2d(d_model // 4), nn.ReLU(inplace=True),
+            nn.Conv2d(d_model // 4, 1, 1))
+
+    def forward(self, x):
+        return self.net(x)                             # (B, 1, H, W)
+
+
+class GatedRefinement(nn.Module):
+    """Boundary-gated fusion of features and semantic logits."""
+
+    def __init__(self, d_model=256, num_classes=20):
+        super().__init__()
+        self.fuse = nn.Sequential(
+            nn.Conv2d(d_model + num_classes, d_model // 2, 3, padding=1,
+                      bias=False),
+            nn.BatchNorm2d(d_model // 2), nn.ReLU(inplace=True),
+            nn.Conv2d(d_model // 2, num_classes, 1))
+
+    def forward(self, feat, sem_logits, bnd_logits):
+        gate = torch.sigmoid(bnd_logits)               # (B, 1, H, W)
+        fused = torch.cat([feat * (1.0 + gate), sem_logits], dim=1)
+        return sem_logits + self.fuse(fused)           # residual refinement
+
+
+class UTAEClassificationDual(nn.Module):
+    def __init__(self, encoder, d_model=256, num_classes=20):
+        super().__init__()
+        self.utae = encoder
+        self.sta = STA(d_model)
+        self.sem_head = SemanticDecoder(d_model, num_classes)
+        self.bnd_head = BoundaryDecoder(d_model)
+        self.refine = GatedRefinement(d_model, num_classes)
+
+    def forward(self, x, pos):
+        out, _ = self.utae(x, pos)                     # (B, H, W, T, D)
+        feat = self.sta(out)                           # (B, D, H, W)
+        sem = self.sem_head(feat)                      # (B, K, H, W)
+        bnd = self.bnd_head(feat)                      # (B, 1, H, W)
+        refined = self.refine(feat, sem, bnd)          # (B, K, H, W)
+        return {"sem_logits": sem,
+                "bnd_logits": bnd,
+                "refined_logits": refined}
+
+
+# ═══════════════════════════════════════════════════════════════════════════
+# 6. Boundary ground truth (recovered verbatim from det pipeline)
+# ═══════════════════════════════════════════════════════════════════════════
+def compute_boundary_target(mask):
+    """
+    Morphological gradient: a pixel is a boundary iff at least one
+    8-neighbour has a different class.
+      mask: (B, H, W) long  ->  boundary: (B, H, W) float in {0, 1}
+    (finetune.py squeezes bnd_logits to (B,H,W), so GT matches that shape.)
+    """
+    m = mask.unsqueeze(1).float()
+    mx = F.max_pool2d(m, 3, 1, 1)
+    mn = -F.max_pool2d(-m, 3, 1, 1)
+    return (mx != mn).float().squeeze(1)

main_method/code/temporal_cnn.py

@@ -0,0 +1,60 @@
+"""Per-pixel spectral time-series CNNs: original mean/max and attention/max variants."""
+import torch
+from torch import nn
+
+def valid_from_index_positions(pos):
+    """The unmodified dataset uses 0,1,...,T-1 and pads positions with zero.
+
+Temporal subsampling may drop acquisition zero; its first retained position is
+then positive. Only an initial zero is a valid acquisition-zero token.
+This cannot be reused for arbitrary calendar positions without a length mask.
+"""
+    first_is_zero = pos[:, :1].eq(0)
+    first = torch.zeros_like(pos, dtype=torch.bool)
+    first[:, :1] = first_is_zero
+    valid = pos.gt(0) | first
+    if not valid.any(dim=1).all():
+        raise ValueError('Each time series must contain an observation')
+    return valid
+
+
+class TemporalCNN(nn.Module):
+    def __init__(self, classes=18):
+        super().__init__()
+        self.input=nn.Linear(10,64)
+        self.norms=nn.ModuleList([nn.LayerNorm(64) for _ in range(4)])
+        self.convs=nn.ModuleList([nn.Conv1d(64,64,3,padding=d,dilation=d,groups=64) for d in [1,2,4,8]])
+        self.mix=nn.ModuleList([nn.Linear(64,64) for _ in range(4)])
+        self.head=nn.Sequential(nn.Linear(128,64),nn.GELU(),nn.Linear(64,classes))
+
+    def forward(self,x,pos):
+        b,t,c,h,w=x.shape
+        valid=valid_from_index_positions(pos)[:,None,None].expand(b,h,w,t).reshape(-1,t,1)
+        flat=x.permute(0,3,4,1,2).reshape(-1,t,c)
+        outputs=[]
+        for start in range(0,len(flat),2048):
+            mask=valid[start:start+2048];z=self.input(flat[start:start+2048])*mask
+            for norm,conv,mix in zip(self.norms,self.convs,self.mix):
+                z=(z+mix(torch.nn.functional.gelu(conv(norm(z).transpose(1,2)).transpose(1,2))))*mask
+            mean=z.sum(1)/mask.sum(1).clamp_min(1)
+            maximum=z.masked_fill(~mask,torch.finfo(z.dtype).min).amax(1)
+            outputs.append(self.head(torch.cat([mean,maximum],-1)))
+        return torch.cat(outputs).reshape(b,h,w,-1).permute(0,3,1,2)
+
+
+class AttentionCNN(TemporalCNN):
+    def __init__(self,classes=18):
+        super().__init__(classes);self.attention=nn.Linear(64,1)
+    def forward(self,x,pos):
+        b,t,c,h,w=x.shape;valid=valid_from_index_positions(pos)[:,None,None].expand(b,h,w,t).reshape(-1,t,1);flat=x.permute(0,3,4,1,2).reshape(-1,t,c);out=[]
+        for start in range(0,len(flat),2048):
+            mask=valid[start:start+2048];z=self.input(flat[start:start+2048])*mask
+            for norm,conv,mix in zip(self.norms,self.convs,self.mix):z=(z+mix(torch.nn.functional.gelu(conv(norm(z).transpose(1,2)).transpose(1,2))))*mask
+            score=self.attention(z).masked_fill(~mask,torch.finfo(z.dtype).min)
+            pooled=(score.softmax(1)*z).sum(1);maximum=z.masked_fill(~mask,torch.finfo(z.dtype).min).amax(1)
+            out.append(self.head(torch.cat([pooled,maximum],-1)))
+        return torch.cat(out).reshape(b,h,w,-1).permute(0,3,1,2)
+
+
+def make_model(kind,classes=18):
+    return {"cnn_control":TemporalCNN,"attention":AttentionCNN}[kind](classes)

main_method/code/temporal_srda.py

@@ -0,0 +1,131 @@
+"""
+Temporal SRDA (T-SRDA) — PDAViT's Spatial-Reduction Dual-Attention
+(Zhou et al., Neurocomputing 2026) adapted to the TEMPORAL axis.
+
+Drop-in replacement for TemporalDaViTEncoder inside UTAE_ASPP.
+Matches its calling convention exactly:
+
+    enc = TemporalSRDAEncoder(d_model=256, n_heads=8, R_schedule=(4, 4, 4))
+    out = enc(x, pos)        # x: (N, T, d)   pos: (N, T, d) date PE or None
+
+Mechanism per block (1D mapping of CUSA + dual attention):
+    KV path : Linear d -> d/R ("point-wise conv")
+              unfold: group R consecutive timesteps -> (N, T/R, d)
+              First SA over T/R tokens (key-value "self-checking")
+    Q path  : full-resolution T tokens
+    Second SA: cross-attention Q(T) x KV(T/R) -> GLOBAL temporal receptive
+              field in a single layer (Swin/DaViT window schedule needs the
+              whole [4,8,16]+shift stack to approximate this).
+    scMLP   : FC -> GELU (+ parallel depth-wise Conv1d over T) -> FC
+
+Design notes (do not change casually):
+  * NO internal gradient checkpointing — UTAE_ASPP already checkpoints at
+    the chunk level (_run_temporal_chunk). Layer-level checkpointing here
+    would recreate the double-checkpoint waste found in the DaViT encoder.
+  * Padding convention matches the existing pipeline: collate_fn zero-pads
+    to batch max_T and the windowed encoders attend over padded steps too.
+    We keep that convention for a clean apples-to-apples ablation. The
+    encoder internally pads T to a multiple of max(R_schedule) and crops
+    back, so any T works (33..61 all fine).
+  * Date PE MUST be added before the KV reduction (handled here: x = x+pos
+    at entry) — grouped KV tokens over irregular acquisitions are
+    meaningless without date information.
+"""
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class TemporalSRDABlock(nn.Module):
+    def __init__(self, d_model=256, n_heads=8, R=4, mlp_ratio=4.0,
+                 attn_drop=0.0, proj_drop=0.0):
+        super().__init__()
+        assert d_model % R == 0, "d_model must be divisible by R"
+        assert d_model % n_heads == 0
+        self.d = d_model
+        self.R = R
+        self.h = n_heads
+        self.dh = d_model // n_heads
+        self.scale = self.dh ** -0.5
+
+        # ---- KV reduction path (CUSA, 1D) ---------------------------------
+        self.norm_kv = nn.LayerNorm(d_model)
+        self.pw = nn.Linear(d_model, d_model // R, bias=False)   # point-wise conv
+        self.norm_first = nn.LayerNorm(d_model)
+        self.first_sa = nn.MultiheadAttention(
+            d_model, n_heads, dropout=attn_drop, batch_first=True)
+
+        # ---- Second (dual) attention ---------------------------------------
+        self.norm_q = nn.LayerNorm(d_model)
+        self.q_proj = nn.Linear(d_model, d_model, bias=False)
+        self.kv_proj = nn.Linear(d_model, 2 * d_model, bias=False)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.out_proj = nn.Linear(d_model, d_model)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+        # ---- scMLP ----------------------------------------------------------
+        hidden = int(d_model * mlp_ratio)
+        self.norm_mlp = nn.LayerNorm(d_model)
+        self.fc1 = nn.Linear(d_model, hidden)
+        self.dw = nn.Conv1d(hidden, hidden, kernel_size=3, padding=1,
+                            groups=hidden)                        # DW over T
+        self.fc2 = nn.Linear(hidden, d_model)
+
+    def forward(self, x):
+        """x: (N, T, d) with T % R == 0 (guaranteed by the encoder wrapper)."""
+        N, T, d = x.shape
+        R = self.R
+
+        # ---- KV path: point-wise conv -> temporal unfold -> first SA -------
+        z = self.pw(self.norm_kv(x))                     # (N, T, d/R)
+        z = z.reshape(N, T // R, R * (d // R))           # unfold -> (N, T/R, d)
+        zn = self.norm_first(z)
+        z_sa, _ = self.first_sa(zn, zn, zn, need_weights=False)
+        kv = z + z_sa                                    # self-checked KV
+
+        # ---- second SA: full-T queries x reduced KV -------------------------
+        q = self.q_proj(self.norm_q(x))
+        k, v = self.kv_proj(kv).chunk(2, dim=-1)
+        q = q.reshape(N, T,  self.h, self.dh).transpose(1, 2)    # (N,h,T,dh)
+        k = k.reshape(N, -1, self.h, self.dh).transpose(1, 2)    # (N,h,T/R,dh)
+        v = v.reshape(N, -1, self.h, self.dh).transpose(1, 2)
+
+        attn = (q @ k.transpose(-2, -1)) * self.scale             # (N,h,T,T/R)
+        attn = self.attn_drop(attn.softmax(dim=-1))
+        out = (attn @ v).transpose(1, 2).reshape(N, T, d)
+        x = x + self.proj_drop(self.out_proj(out))
+
+        # ---- scMLP -----------------------------------------------------------
+        y = self.fc1(self.norm_mlp(x))
+        y = F.gelu(y) + self.dw(y.transpose(1, 2)).transpose(1, 2)
+        x = x + self.fc2(y)
+        return x
+
+
+class TemporalSRDAEncoder(nn.Module):
+    """
+    Signature-compatible replacement for TemporalDaViTEncoder.
+    forward(x, pos=None): x (N, T, d), pos (N, T, d) date positional encoding.
+    """
+    def __init__(self, d_model=256, n_heads=8, R_schedule=(4, 4, 4), **kwargs):
+        super().__init__()
+        # **kwargs silently absorbs legacy windows=/shifts= if passed through
+        self.R_max = max(R_schedule)
+        self.blocks = nn.ModuleList(
+            TemporalSRDABlock(d_model, n_heads, R=r) for r in R_schedule)
+
+    def forward(self, x, pos=None):
+        if pos is not None:
+            x = x + pos                       # date PE BEFORE KV reduction
+
+        N, T, d = x.shape
+        pad = (-T) % self.R_max               # pad T up to multiple of R_max
+        if pad:
+            x = F.pad(x, (0, 0, 0, pad))      # zero-pad — matches pipeline
+
+        for blk in self.blocks:
+            x = blk(x)
+
+        if pad:
+            x = x[:, :T]
+        return x

main_method/code/train_feature_clusters.py

@@ -0,0 +1,377 @@
+"""Frozen-depth probes and patch-balanced prototype readouts on official fixed32.
+
+Caches only masked temporal mean/std summaries, not full time-series features.
+The readout sees 18 classes; probabilities are mapped to the original 20 channels.
+Validation is selection-only. Prototype banks and normalization use training only.
+"""
+import argparse
+import json
+import time
+from pathlib import Path
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from sklearn.cluster import KMeans
+import config as C
+from dataset import (PASTISPatchDataset, train_patch_ids, val_patch_ids,
+                     test_patch_ids, pad_collate, crop_ij)
+from model import UTAE_ASPP, UTAEClassificationDual
+from temporal_cnn import valid_from_index_positions
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / 'main_method' / 'runs' / 'feature_cluster_readouts'
+SAM = ROOT / 'main_method/checkpoints/shared/sam_network_seed3407.tar'
+PRETRAIN = ROOT / 'checkpoints/pretrain/latest.utae.tar'
+
+
+def write_json(path, data):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_suffix('.json.tmp')
+    temp.write_text(json.dumps(data, indent=2))
+    temp.replace(path)
+
+
+def metrics(y, pred):
+    valid = (y > 0) & (y < 19)
+    cm = np.bincount(20 * y[valid].astype(np.int64) + pred[valid],
+                     minlength=400).reshape(20, 20)
+    return metrics_cm(cm)
+
+
+def metrics_cm(cm):
+    tp = np.diag(cm)[1:19].astype(float)
+    gt, pp = cm.sum(1)[1:19], cm.sum(0)[1:19]
+    iou = tp / np.maximum(gt + pp - tp, 1)
+    f1 = 2 * tp / np.maximum(gt + pp, 1)
+    total = cm.sum()
+    oa = cm.trace() / max(total, 1)
+    chance = np.dot(cm.sum(0).astype(float), cm.sum(1)) / max(total ** 2, 1)
+    return {'miou': float(iou.mean()), 'oa': float(oa),
+            'macro_f1': float(f1.mean()), 'kappa': float((oa-chance)/max(1-chance,1e-12)),
+            'per_class_iou': iou.tolist(), 'confusion_matrix': cm.tolist()}
+
+
+def frozen_model(source, device):
+    enc = UTAE_ASPP(n_channels=C.N_CHANNELS, d_model=C.D_MODEL, n_heads=C.N_HEADS)
+    net = UTAEClassificationDual(enc, d_model=C.D_MODEL, num_classes=C.N_CLASSES)
+    ck = torch.load(SAM if source == 'sam' else PRETRAIN,
+                    map_location='cpu', weights_only=False)
+    state = ck['model_state_dict']
+    if source == 'sam':
+        net.load_state_dict(state, strict=True)
+    else:
+        if not any(k.startswith('spatial_encoder.') for k in state):
+            state = {k[5:]: v for k, v in state.items() if k.startswith('utae.')}
+        enc.load_state_dict(state, strict=True)
+    return net.to(device).eval().requires_grad_(False)
+
+
+class DepthCollector:
+    def __init__(self, encoder):
+        self.handles = [block.register_forward_hook(self.hook(i))
+                        for i, block in enumerate(encoder.temporal_encoder.blocks)]
+
+    def begin(self, x, pos):
+        b, _, _, h, w = x.shape
+        self.shape = b, h, w
+        self.valid = valid_from_index_positions(pos)[:, None, None]
+        self.valid = self.valid.expand(b, h, w, -1).reshape(b*h*w, -1)
+        self.parts = [[], [], []]
+        self.offsets = [0, 0, 0]
+
+    def hook(self, depth):
+        def collect(module, inputs, output):
+            start = self.offsets[depth]
+            valid = self.valid[start:start + output.shape[0]]
+            if valid.shape[1] < output.shape[1]:
+                valid = F.pad(valid, (0, output.shape[1]-valid.shape[1]), value=False)
+            weights = valid[..., None].float()
+            values = output.float()
+            count = weights.sum(1).clamp_min(1)
+            mean = (values * weights).sum(1) / count
+            var = ((values - mean[:, None]).square() * weights).sum(1) / count
+            summary = torch.cat((mean, var.clamp_min(0).sqrt()), -1)
+            self.parts[depth].append(summary.detach().half().cpu().numpy())
+            self.offsets[depth] += len(output)
+        return collect
+
+    def end(self):
+        assert self.offsets == [np.prod(self.shape)] * 3
+        return np.stack([np.concatenate(parts) for parts in self.parts], axis=1)
+
+    def close(self):
+        for handle in self.handles:
+            handle.remove()
+
+
+def extract_cache():
+    device = torch.device('cuda')
+    started = time.monotonic()
+    manifest = {'feature': 'valid-timestep mean/std at blocks 1,2,3; float16 summaries',
+                'crop_size': 32, 'batch': 2, 'sources': {}, 'normalizer': 'original',
+                'positions': 'original acquisition indices'}
+    for source in ('sam', 'pretrain'):
+        model = frozen_model(source, device)
+        collector = DepthCollector(model.utae)
+        for split, ids in [('train', train_patch_ids()), ('val', val_patch_ids())]:
+            folder = OUT/'cache'/source/split
+            folder.mkdir(parents=True, exist_ok=True)
+            n = len(ids) * 2 * 32 * 32
+            files = {
+                'features': ((n, 3, 512), np.float16),
+                'labels': ((n,), np.uint8), 'patch_ids': ((n,), np.int32),
+                'crop_ids': ((n,), np.uint8),
+            }
+            if source == 'sam':
+                files['base_probs'] = ((n, 20), np.float32)
+            arrays = {k: np.lib.format.open_memmap(folder/f'{k}.npy',mode='w+',dtype=dtype,shape=shape)
+                      for k,(shape,dtype) in files.items()}
+            loader = DataLoader(PASTISPatchDataset(ids), batch_size=2, shuffle=False,
+                                num_workers=2, pin_memory=True, collate_fn=pad_collate)
+            offset = 0
+            with torch.inference_mode():
+                for bi, ((x, pos, _), y) in enumerate(loader):
+                    x, pos = x.to(device), pos.to(device)
+                    batch_ids = ids[2*bi:2*bi+x.shape[0]]
+                    for crop_index, (i, j) in enumerate(C.FT_CROP_IJ):
+                        crop, target = crop_ij(x, y, i, j, C.PRETRAIN_CROP_GRID)
+                        collector.begin(crop, pos)
+                        with torch.autocast('cuda', dtype=torch.float16):
+                            result = model(crop, pos) if source == 'sam' else model.utae(crop,pos)
+                        features = collector.end()
+                        end = offset + len(features)
+                        arrays['features'][offset:end] = features
+                        arrays['labels'][offset:end] = target.numpy().reshape(-1)
+                        arrays['patch_ids'][offset:end] = np.repeat(batch_ids,32*32)
+                        arrays['crop_ids'][offset:end] = crop_index
+                        if source == 'sam':
+                            pp = result['refined_logits'].float().softmax(1)
+                            arrays['base_probs'][offset:end] = pp.permute(0,2,3,1).reshape(-1,20).cpu().numpy()
+                        offset = end
+                    if bi % 10 == 0:
+                        print('cache',source,split,bi,len(loader),flush=True)
+            assert offset == n
+            for array in arrays.values():
+                array.flush()
+            manifest['sources'][f'{source}_{split}'] = {'pixels':n,'entries':len(ids),
+                                                       'unique_patches':len(set(ids))}
+            del arrays
+        collector.close()
+        del model
+        torch.cuda.empty_cache()
+    y = np.load(OUT/'cache/sam/val/labels.npy')
+    p = np.load(OUT/'cache/sam/val/base_probs.npy',mmap_mode='r')
+    manifest['sam_baseline'] = metrics(y,p.argmax(1))
+    if abs(manifest['sam_baseline']['miou']-.5000673383500418)>1e-6:
+        raise RuntimeError('Feature-cache SAM baseline does not reproduce its stored score')
+    manifest['seconds'] = time.monotonic()-started
+    write_json(OUT/'cache/manifest.json',manifest)
+
+
+def load_cache(source, split):
+    folder = OUT/'cache'/source/split
+    return {name:np.load(folder/f'{name}.npy',mmap_mode='r')
+            for name in ('features','labels','patch_ids','crop_ids')}
+
+
+def rows(features, indices, depth):
+    data = np.asarray(features[indices])
+    return (data[:,depth,:] if depth>=0 else data.reshape(len(data),-1)).astype(np.float32)
+
+
+def train_normalizer(features, indices, depth):
+    width = 512 if depth>=0 else 1536
+    sums, squares = np.zeros(width,np.float64),np.zeros(width,np.float64)
+    for start in range(0,len(indices),4096):
+        x = rows(features,indices[start:start+4096],depth).astype(np.float64)
+        sums += x.sum(0);squares += (x*x).sum(0)
+    mean = sums/len(indices)
+    std = np.sqrt(np.maximum(squares/len(indices)-mean*mean,0)).clip(.05)
+    return torch.from_numpy(mean.astype(np.float32)).cuda(),torch.from_numpy(std.astype(np.float32)).cuda()
+
+
+def normalized(features, indices, depth, mean, std):
+    return (torch.from_numpy(rows(features,indices,depth)).cuda()-mean)/std
+
+
+def make_prototypes(train, depth, mean, std, seed):
+    rng = np.random.default_rng(seed)
+    # Only the first occurrence of each (patch,crop) enters prototype memory.
+    pid, cid, labels = train['patch_ids'],train['crop_ids'],train['labels']
+    unique = np.zeros(len(labels),bool);seen=set()
+    for start in range(0,len(labels),1024):
+        key=int(pid[start]),int(cid[start])
+        if key not in seen:
+            unique[start:start+1024]=True;seen.add(key)
+    protos=[]
+    for cls in range(1,19):
+        memory=[]
+        for patch in np.unique(pid[unique & (labels==cls)]):
+            eligible=np.flatnonzero(unique & (pid==patch) & (labels==cls))
+            memory.extend(rng.choice(eligible,32,replace=len(eligible)<32).tolist())
+        if not memory:
+            raise RuntimeError(f'No training prototype support for class {cls}')
+        embeddings=F.normalize(normalized(train['features'],np.array(memory),depth,mean,std),dim=1)
+        km=KMeans(n_clusters=3,n_init=3,random_state=seed).fit(embeddings.cpu().numpy())
+        centers=F.normalize(torch.from_numpy(km.cluster_centers_).cuda(),dim=1)
+        protos.append(centers)
+    return torch.stack(protos)
+
+
+def fit_linear(train, depth, mean, std, seed):
+    torch.manual_seed(seed)
+    width=len(mean)
+    head=torch.nn.Linear(width,18).cuda()
+    optimizer=torch.optim.AdamW(head.parameters(),lr=1e-3,weight_decay=1e-3)
+    rng=np.random.default_rng(seed)
+    eligible=np.flatnonzero((train['labels']>0)&(train['labels']<19))
+    for epoch in range(30):
+        shuffled=rng.permutation(eligible)
+        for start in range(0,len(shuffled),4096):
+            ix=shuffled[start:start+4096]
+            x=normalized(train['features'],ix,depth,mean,std)
+            y=torch.from_numpy(np.asarray(train['labels'][ix]).astype(np.int64)-1).cuda()
+            optimizer.zero_grad(set_to_none=True)
+            F.cross_entropy(head(x),y).backward();optimizer.step()
+    return {k:v.detach() for k,v in head.state_dict().items()}
+
+
+def probability(features, depth, mean, std, kind, state):
+    out=np.zeros((len(features),20),np.float32)
+    with torch.inference_mode():
+        for start in range(0,len(features),4096):
+            ix=np.arange(start,min(start+4096,len(features)))
+            x=normalized(features,ix,depth,mean,std)
+            if kind=='linear':
+                logits=F.linear(x,state['weight'],state['bias'])
+            else:
+                embeddings=F.normalize(x,dim=-1)
+                logits=torch.einsum('nd,ckd->nck',embeddings,state)/.1
+                logits=logits.logsumexp(-1)-np.log(3)
+            out[start:start+len(ix),1:19]=logits.softmax(-1).cpu().numpy()
+    return out
+
+
+def bootstrap(y, pred, baseline, patch_ids):
+    unique=np.unique(patch_ids);a=[];b=[]
+    for pid in unique:
+        m=patch_ids==pid;valid=m&(y>0)&(y<19)
+        a.append(np.bincount(20*y[valid].astype(int)+pred[valid],minlength=400).reshape(20,20))
+        b.append(np.bincount(20*y[valid].astype(int)+baseline[valid],minlength=400).reshape(20,20))
+    a,b=np.array(a),np.array(b);rng=np.random.default_rng(3407);d=[]
+    for _ in range(1000):
+        ix=rng.integers(0,len(unique),len(unique))
+        d.append(100*(metrics_cm(a[ix].sum(0))['miou']-metrics_cm(b[ix].sum(0))['miou']))
+    return np.percentile(d,[2.5,97.5]).tolist()
+
+
+def fit_readouts():
+    if not (OUT/'cache/manifest.json').exists():
+        raise RuntimeError('Incomplete feature cache')
+    started=time.monotonic();records=[];models={};families={}
+    base=np.load(OUT/'cache/sam/val/base_probs.npy',mmap_mode='r')
+    target=np.load(OUT/'cache/sam/val/labels.npy')
+    baseline=metrics(target,base.argmax(1))['miou']
+    for source in ('sam','pretrain'):
+        train,val=load_cache(source,'train'),load_cache(source,'val')
+        assert np.array_equal(target,val['labels'])
+        eligible=np.flatnonzero((train['labels']>0)&(train['labels']<19))
+        for depth in (0,1,2,-1):
+            mean,std=train_normalizer(train['features'],eligible,depth)
+            for seed in (3407,42,1234):
+                for kind in ('linear','prototype'):
+                    state=fit_linear(train,depth,mean,std,seed) if kind=='linear' else make_prototypes(train,depth,mean,std,seed)
+                    pp=probability(val['features'],depth,mean,std,kind,state)
+                    name=f'{source}_depth{depth}_{kind}_seed{seed}'
+                    path=OUT/'readouts'/f'{name}.tar';path.parent.mkdir(parents=True,exist_ok=True)
+                    cpu_state={k:v.cpu() for k,v in state.items()} if kind=='linear' else state.cpu()
+                    torch.save({'source':source,'depth':depth,'kind':kind,'seed':seed,
+                                'mean':mean.cpu(),'std':std.cpu(),'state':cpu_state},path)
+                    for alpha in (1.,.1,.25,.5):
+                        pred=((1-alpha)*base+alpha*pp).argmax(1)
+                        m=metrics(target,pred)
+                        family=f'{source}_depth{depth}_{kind}_alpha{alpha}'
+                        entry={'source':source,'depth':depth,'kind':kind,'seed':seed,
+                               'alpha':alpha,'metrics':m,'checkpoint':str(path),'family':family}
+                        records.append(entry);families.setdefault(family,[]).append(entry)
+                    print(name,'unblended',records[-4]['metrics']['miou'],flush=True)
+                    write_json(OUT/'probe_progress.json',{'completed_readouts':len(records)//4,'total_readouts':48})
+            del mean,std
+        del train,val
+    ranked=sorted(families.items(),key=lambda kv:np.mean([e['metrics']['miou'] for e in kv[1]]),reverse=True)
+    family,entries=ranked[0]
+    mean_score=float(np.mean([e['metrics']['miou'] for e in entries]))
+    # Fixed seed deployment representative, never choose a seed by test score.
+    chosen=next(e for e in entries if e['seed']==3407)
+    ck=torch.load(chosen['checkpoint'],map_location='cpu',weights_only=False)
+    ck['alpha']=chosen['alpha'];torch.save(ck,OUT/'probe_best.tar')
+    val=load_cache(chosen['source'],'val')
+    state={k:v.cuda() for k,v in ck['state'].items()} if ck['kind']=='linear' else ck['state'].cuda()
+    pp=probability(val['features'],ck['depth'],ck['mean'].cuda(),ck['std'].cuda(),ck['kind'],state)
+    pred=((1-ck['alpha'])*base+ck['alpha']*pp).argmax(1)
+    result={'baseline_miou':baseline,'selected_family':family,'family_mean_val_miou':mean_score,
+            'family_std_val_miou':float(np.std([e['metrics']['miou'] for e in entries],ddof=1)),
+            'delta_mean_pp':100*(mean_score-baseline),'selected':chosen,
+            'paired_patch_delta_ci95_pp':bootstrap(target,pred,base.argmax(1),val['patch_ids']),
+            'promote':bool(mean_score>=baseline+.005),'records':records,
+            'seconds':time.monotonic()-started,'test_used_for_selection':False,
+            'scope':'Readout seeds vary on the same frozen encoder; not full encoder training seeds.'}
+    write_json(OUT/'probe_results.json',result)
+    print('Selected',family,'mean validation',mean_score,'promote',result['promote'],flush=True)
+
+
+def evaluate_selected(split):
+    ck=torch.load(OUT/'probe_best.tar',map_location='cpu',weights_only=False)
+    device=torch.device('cuda');base=frozen_model('sam',device)
+    encoder_model=base if ck['source']=='sam' else frozen_model('pretrain',device)
+    collector=DepthCollector(encoder_model.utae)
+    ids=val_patch_ids() if split=='val' else test_patch_ids()
+    batch=2 if split=='val' else 1
+    loader=DataLoader(PASTISPatchDataset(ids),batch_size=batch,shuffle=False,num_workers=2,
+                      pin_memory=True,collate_fn=pad_collate)
+    state={k:v.cuda() for k,v in ck['state'].items()} if ck['kind']=='linear' else ck['state'].cuda()
+    cm=np.zeros((20,20),np.int64);started=time.monotonic()
+    with torch.inference_mode():
+        for bi,((x,pos,_),y) in enumerate(loader):
+            x,pos=x.to(device),pos.to(device)
+            grid=4 if split=='val' else 1
+            crops=C.FT_CROP_IJ if split=='val' else [(0,0)]
+            for i,j in crops:
+                crop,target=crop_ij(x,y,i,j,grid)
+                collector.begin(crop,pos)
+                with torch.autocast('cuda',dtype=torch.float16):
+                    output=base(crop,pos)
+                    if encoder_model is not base:
+                        encoder_model.utae(crop,pos)
+                features=collector.end()
+                bp=output['refined_logits'].float().softmax(1).permute(0,2,3,1).reshape(-1,20).cpu().numpy()
+                pp=probability(features,ck['depth'],ck['mean'].cuda(),ck['std'].cuda(),ck['kind'],state)
+                pred=((1-ck['alpha'])*bp+ck['alpha']*pp).argmax(1)
+                gt=target.numpy().reshape(-1);valid=(gt>0)&(gt<19)
+                cm+=np.bincount(20*gt[valid].astype(int)+pred[valid],minlength=400).reshape(20,20)
+            if bi%25==0:print('probe evaluation',split,bi,len(loader),flush=True)
+    collector.close()
+    result={'metrics':metrics_cm(cm),'seconds':time.monotonic()-started,
+            'entries':len(ids),'batch':batch,'full_patch':split=='test',
+            'checkpoint':str(OUT/'probe_best.tar'),'source':ck['source'],'alpha':ck['alpha']}
+    write_json(OUT/f'probe_{split}_results.json',result)
+    if split=='val':
+        expected=json.loads((OUT/'probe_results.json').read_text())['selected']['metrics']['miou']
+        if abs(result['metrics']['miou']-expected)>1e-6:
+            raise RuntimeError('Online readout validation does not match cache selection')
+    print(result,flush=True)
+
+
+def main():
+    parser=argparse.ArgumentParser();parser.add_argument('action',choices=['cache','fit','validate','test'])
+    args=parser.parse_args();OUT.mkdir(exist_ok=True)
+    torch.set_num_threads(4);torch.manual_seed(3407)
+    torch.backends.cuda.matmul.allow_tf32=True
+    torch.backends.cudnn.allow_tf32=True
+    if args.action=='cache':extract_cache()
+    elif args.action=='fit':fit_readouts()
+    else:evaluate_selected('val' if args.action=='validate' else 'test')
+
+
+if __name__=='__main__':main()

main_method/code/train_spatial_temporal.py

@@ -0,0 +1,762 @@
+"""
+T-SRDA finetune v2 — improved recipe for Kaggle (T4 x 2).
+
+The v1 run (official STCLN protocol: fixed 32x32 diagonal crops, no
+augmentation, flat LR 1e-4, wd=0) peaked at val mIoU 0.4759 around epoch 37
+and then DECLINED to 0.4207 by epoch 99 — textbook overfitting to the 152
+fixed training crops. v2 attacks exactly that, while keeping everything that
+made v1 comparable intact.
+
+NEW in v2
+---------
+1. RANDOM CROPS anywhere in the 128x128 patch (default 64x64, 2 per patch
+   per epoch) instead of the two fixed 32x32 diagonal crops (0,0)/(1,1).
+   Every epoch sees different windows, and 64x64 gives 4x the spatial
+   context of the official 32x32 plus more parcel boundaries per crop.
+2. AUGMENTATION (v1/official: none):
+     - dihedral-8 (h/v flip + rot90)                     always sampled
+     - temporal subsample (drop up to 20% of frames, order kept)  p=0.5
+     - frame dropout (zero 1-2 whole frames ~ cloudy acquisition) p=0.25
+     - per-band gain/bias jitter + small gaussian noise  always
+3. AdamW with weight decay 0.02 on >1-dim params (v1 used wd=0 == Adam).
+4. DISCRIMINATIVE LR: the pretrained encoder trains at 0.5x the head LR,
+   so 43 h of pretraining is not washed out by the randomly-init heads.
+5. WARMUP (3 ep) + COSINE decay to 1% (v1: flat 1e-4, no schedule).
+6. EMA of weights (decay 0.999) — raw AND EMA are validated every epoch and
+   each keeps its own best checkpoint. EMA is usually the better one.
+7. Label smoothing 0.05 on the CE terms.
+8. Best-val checkpointing + early stopping (--patience), and a resumable
+   latest.tar every epoch (Kaggle sessions can die — --resume auto).
+
+KEPT IDENTICAL to v1 (so numbers stay comparable to the 0.4124/0.4433 run)
+--------------------------------------------------------------------------
+  - model architecture (UTAE_ASPP + UTAEClassificationDual); the pretrained
+    encoder is loaded strict=True from the .utae.tar checkpoint
+  - loss family: CE + 0.75*Lovász on the sem & refined heads + 0.5*BCE on
+    the boundary head; uniform class weights with 0/19 ignored (the
+    inverse-frequency weighting experiment is NOT repeated — it was a
+    catastrophic regression in this project)
+  - splits: the same 76 train / 76 val hardcoded patch IDs, fold-4 test
+  - index positions (arange(T)), AMP, grad clip 5.0, seed protocol
+  - same optimizer-step budget: 2 patches/batch x 2 crops = 76 steps/epoch
+
+DDP: launch with torchrun to use both T4s (one run, half the wall time):
+  torchrun --standalone --nproc_per_node=2 finetune_v2.py --pretrain_pth ...
+"""
+import argparse
+import copy
+import json
+import math
+import os
+import random
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.distributed as dist
+from torch.utils.data import DataLoader, DistributedSampler
+from torch.cuda.amp import autocast, GradScaler
+from torch.nn.parallel import DistributedDataParallel as DDP
+from sklearn.metrics import confusion_matrix, cohen_kappa_score
+
+import config as C
+from dataset import (PASTISPatchDataset, train_patch_ids, val_patch_ids,
+                     pad_collate, crop_ij)
+from model import UTAE_ASPP, UTAEClassificationDual, compute_boundary_target
+from losses import LovaszSoftmaxLoss
+
+PASTIS_NAMES = C.PASTIS_CLASSES   # single source of truth — see config.py
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Distributed helpers (same contract as v1: torchrun env vars, else single GPU)
+# ─────────────────────────────────────────────────────────────────────────────
+def setup_distributed():
+    if "RANK" in os.environ:
+        dist.init_process_group(backend="nccl")
+        local_rank = int(os.environ["LOCAL_RANK"])
+        rank       = int(os.environ["RANK"])
+        world      = int(os.environ["WORLD_SIZE"])
+        torch.cuda.set_device(local_rank)
+        return rank, world, local_rank, torch.device(f"cuda:{local_rank}")
+    return 0, 1, 0, torch.device("cuda:0")
+
+
+def cleanup_distributed():
+    if dist.is_initialized():
+        dist.destroy_process_group()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Metrics — identical to v1 finetune.py
+# ─────────────────────────────────────────────────────────────────────────────
+def compute_all_metrics(preds_np, labels_np, num_classes=20):
+    class_ids = list(range(1, num_classes - 1))   # 1..18 scored
+
+    valid = (labels_np > 0) & (labels_np < num_classes - 1)
+    pv = preds_np[valid]
+    lv = labels_np[valid]
+
+    if len(lv) == 0:
+        return dict(miou=0.0, oa=0.0, mf1=0.0, kappa=0.0,
+                    per_iou={}, per_f1={})
+
+    cm = confusion_matrix(lv, pv, labels=class_ids)
+    diag = np.diag(cm).astype(np.float64)
+    sum0 = cm.sum(0).astype(np.float64)
+    sum1 = cm.sum(1).astype(np.float64)
+
+    iou   = diag / (sum0 + sum1 - diag + 1e-8)
+    f1    = (2 * diag) / (sum0 + sum1 + 1e-8)
+    miou  = float(iou.mean())
+    mf1   = float(f1.mean())
+    oa    = float((pv == lv).mean())
+    kappa = float(cohen_kappa_score(lv, pv))
+
+    return dict(miou=miou, oa=oa, mf1=mf1, kappa=kappa,
+                per_iou={c: float(iou[i]) for i, c in enumerate(class_ids)},
+                per_f1={c: float(f1[i]) for i, c in enumerate(class_ids)})
+
+
+def print_metrics(metrics, tag):
+    print(f"  [{tag}] mIoU={metrics['miou']:.4f}  OA={metrics['oa']:.4f}  "
+          f"mF1={metrics['mf1']:.4f}  Kappa={metrics['kappa']:.4f}", flush=True)
+    print(f"  {'Cls':>4} {'Name':<28} {'IoU':>8} {'F1':>8}", flush=True)
+    print(f"  {'-'*44}", flush=True)
+    for c in range(1, C.N_CLASSES - 1):
+        iv = metrics['per_iou'].get(c, 0.0)
+        fv = metrics['per_f1'].get(c, 0.0)
+        name = PASTIS_NAMES.get(c, f"cls{c}")
+        flag = "  **DEAD**" if iv < 0.001 else ("  *rare*" if iv < 0.10 else "")
+        print(f"  {c:>4} {name:<28} {iv:>8.4f} {fv:>8.4f}{flag}", flush=True)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# v2 augmentations. All operate on one batch of crops:
+#   xc  (B, T, C, h, w)   normalized S2
+#   yc  (B, h, w)         labels
+#   pos (B, T)            index positions (arange(T) upstream)
+# ─────────────────────────────────────────────────────────────────────────────
+def aug_dihedral(xc, yc):
+    """One dihedral-8 transform per crop-batch, image and label together."""
+    if torch.rand(()) > 0.5:
+        xc, yc = xc.flip(-2), yc.flip(-2)
+    if torch.rand(()) > 0.5:
+        xc, yc = xc.flip(-1), yc.flip(-1)
+    k = int(torch.randint(0, 4, ()))
+    if k:
+        xc, yc = torch.rot90(xc, k, (-2, -1)), torch.rot90(yc, k, (-2, -1))
+    return xc.contiguous(), yc.contiguous()
+
+
+def aug_temporal_subsample(xc, pos, p=0.5, drop_max=0.2, keep_min=24):
+    """Drop up to `drop_max` of the frames, order preserved. Positions keep
+    their original index values -> emulates missing acquisitions of an
+    otherwise identical season. No-op with probability 1-p."""
+    if torch.rand(()) > p:
+        return xc, pos
+    T = xc.shape[1]
+    keep = int(round(T * (1.0 - random.uniform(0.0, drop_max))))
+    keep = max(keep_min, min(T, keep))
+    if keep >= T:
+        return xc, pos
+    idx = torch.randperm(T)[:keep].sort().values.to(xc.device)
+    return (xc.index_select(1, idx).contiguous(),
+            pos.index_select(1, idx).contiguous())
+
+
+def aug_frame_dropout(xc, p=0.25, max_frames=2):
+    """Zero 1-2 whole frames (0 == dataset mean after normalisation) —
+    emulates cloudy/lost acquisitions."""
+    if torch.rand(()) > p:
+        return xc
+    T = xc.shape[1]
+    n = random.randint(1, max_frames)
+    idx = torch.randperm(T)[:n].to(xc.device)
+    xc = xc.clone()
+    xc[:, idx] = 0.0
+    return xc
+
+
+def aug_spectral(xc, gain_std=0.05, bias_std=0.03, noise_std=0.01):
+    """Per-sample, per-band gain/bias jitter + small gaussian noise (data is
+    z-normalised, so these are fractions of one std)."""
+    B, T, Ch, H, W = xc.shape
+    dev = xc.device
+    gain = 1.0 + gain_std * torch.randn(B, 1, Ch, 1, 1, device=dev)
+    bias = bias_std * torch.randn(B, 1, Ch, 1, 1, device=dev)
+    xc = xc * gain + bias
+    if noise_std > 0:
+        xc = xc + noise_std * torch.randn_like(xc)
+    return xc.contiguous()
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# EMA of the raw (unwrapped) network
+# ─────────────────────────────────────────────────────────────────────────────
+class ModelEMA:
+    def __init__(self, model, decay=0.999):
+        self.decay = decay
+        self.updates = 0
+        raw = model.module if isinstance(model, DDP) else model
+        self.module = copy.deepcopy(raw).eval()
+        for p in self.module.parameters():
+            p.requires_grad_(False)
+
+    @torch.no_grad()
+    def update(self, model):
+        self.updates += 1
+        d = min(self.decay, (1.0 + self.updates) / (10.0 + self.updates))
+        raw = model.module if isinstance(model, DDP) else model
+        msd = raw.state_dict()
+        for k, v in self.module.state_dict().items():
+            if v.dtype.is_floating_point:
+                v.lerp_(msd[k].detach().float(), 1.0 - d)
+            else:
+                v.copy_(msd[k])
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Optimizer param groups: encoder vs heads x decay vs no-decay
+# ─────────────────────────────────────────────────────────────────────────────
+def build_param_groups(net_raw, base_lr, encoder_mult, wd):
+    buckets = {"enc_dec": [], "enc_nd": [], "head_dec": [], "head_nd": []}
+    for name, p in net_raw.named_parameters():
+        if not p.requires_grad:
+            continue
+        is_enc = name.startswith("utae.")
+        no_dec = p.ndim <= 1                     # LN/BN weights + all biases
+        buckets[("enc_" if is_enc else "head_") + ("nd" if no_dec else "dec")
+                ].append(p)
+    groups = [
+        {"params": buckets["enc_dec"],  "lr0": base_lr * encoder_mult,
+         "weight_decay": wd},
+        {"params": buckets["enc_nd"],   "lr0": base_lr * encoder_mult,
+         "weight_decay": 0.0},
+        {"params": buckets["head_dec"], "lr0": base_lr,
+         "weight_decay": wd},
+        {"params": buckets["head_nd"],  "lr0": base_lr,
+         "weight_decay": 0.0},
+    ]
+    return [g for g in groups if len(g["params"]) > 0]
+
+
+def lr_factor(step, total_steps, warmup_steps, min_ratio):
+    """Linear warmup then cosine decay to min_ratio."""
+    if step < warmup_steps:
+        return (step + 1) / max(1, warmup_steps)
+    p = (step - warmup_steps) / max(1, total_steps - warmup_steps)
+    p = min(1.0, p)
+    cos = 0.5 * (1.0 + math.cos(math.pi * p))
+    return min_ratio + (1.0 - min_ratio) * cos
+
+
+def set_lrs(optimizer, factor):
+    for g in optimizer.param_groups:
+        g["lr"] = g["lr0"] * factor
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Validation on the two fixed diagonal crops of the val patches
+# (grid = PATCH_SIZE / crop_size; for 64 -> (0,0),(1,1) of a 2x2 grid,
+#  for 32 -> exactly the official v1 validation crops)
+# ─────────────────────────────────────────────────────────────────────────────
+@torch.no_grad()
+def validate(net, val_dl, device, crop_size, limit_batches=0):
+    net.eval()
+    grid = max(1, C.PATCH_SIZE // crop_size)
+    positions = [(0, 0), (1, 1)] if grid >= 2 else [(0, 0)]
+    all_preds, all_labels = [], []
+    for bi, ((xv, pv_, _dv), yv) in enumerate(val_dl):
+        if limit_batches and bi >= limit_batches:
+            break
+        xv  = xv.to(device, non_blocking=True)
+        pv_ = pv_.to(device, non_blocking=True)
+        yv  = yv.to(device, non_blocking=True)
+        for (i, j) in positions:
+            xc, yc = crop_ij(xv, yv, i, j, grid)
+            with autocast():
+                out = net(xc, pv_)
+            pred = out["refined_logits"].float().argmax(dim=1)
+            all_preds.append(pred.cpu().numpy().ravel())
+            all_labels.append(yc.cpu().numpy().ravel())
+    return compute_all_metrics(np.concatenate(all_preds),
+                               np.concatenate(all_labels), C.N_CLASSES)
+
+
+def pack_checkpoint(state_dict, epoch, metrics, seed, which):
+    return {"epoch": epoch,
+            "model_state_dict": state_dict,
+            "val_miou":  metrics["miou"],
+            "val_oa":    metrics["oa"],
+            "val_mf1":   metrics["mf1"],
+            "val_kappa": metrics["kappa"],
+            "val_per_iou": metrics["per_iou"],
+            "seed": seed, "which": which, "recipe": "v2"}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pretrain_pth", type=str, required=True)
+    ap.add_argument("--seed",     type=int, default=C.SEED)
+    ap.add_argument("--tag",      type=str, default="v2")
+    ap.add_argument("--out_dir",  type=str, default="",
+                    help="default: <EXP_ROOT>/checkpoints/finetune_v2/<tag>")
+    ap.add_argument("--epochs",   type=int, default=C.FT_EPOCHS)
+    ap.add_argument("--batch",    type=int, default=C.FT_BATCH)
+    # --- the v2 recipe knobs -------------------------------------------------
+    ap.add_argument("--crop_size", type=int, default=64,
+                    help="random-crop side; 32 = official crop size")
+    ap.add_argument("--crops_per_patch", type=int, default=2,
+                    help="random crops per patch per epoch (2 keeps the "
+                         "official 76 steps/epoch)")
+    ap.add_argument("--official_crops", action="store_true",
+                    help="control run: fixed 32x32 diagonal crops, no augs "
+                         "(= v1 recipe with v2 plumbing)")
+    ap.add_argument("--fixed_crops", action="store_true",
+                    help="fixed diagonal crops at --crop_size; keeps augmentation settings")
+    ap.add_argument("--freeze_encoder_epochs", type=int, default=0)
+    ap.add_argument("--no_aug", action="store_true")
+    ap.add_argument("--no_temporal_aug", action="store_true")
+    ap.add_argument("--mask_ce_invalid", action="store_true")
+    ap.add_argument("--boundary_weight", type=float, default=0.5)
+    ap.add_argument("--init_finetuned", type=str, default="",
+                    help="initialize all weights from fine-tuned checkpoint; reset optimizer and schedule")
+    ap.add_argument("--base_lr",  type=float, default=1e-4)
+    ap.add_argument("--encoder_lr_mult", type=float, default=0.5)
+    ap.add_argument("--min_lr_ratio", type=float, default=0.01)
+    ap.add_argument("--warmup_epochs", type=float, default=3.0)
+    ap.add_argument("--wd", type=float, default=0.02)
+    ap.add_argument("--label_smoothing", type=float, default=0.05)
+    ap.add_argument("--ema_decay", type=float, default=0.999)
+    ap.add_argument("--patience", type=int, default=30,
+                    help="early stopping on val mIoU; 0 = run all epochs")
+    # --- housekeeping --------------------------------------------------------
+    ap.add_argument("--print_every", type=int, default=5)
+    ap.add_argument("--limit_batches", type=int, default=0,
+                    help=">0: truncate train/val loops (smoke test)")
+    ap.add_argument("--resume", type=str, default="auto",
+                    help="'auto' resumes from <out_dir>/latest.tar if present; "
+                         "'none' starts fresh; or an explicit .tar path")
+    ap.add_argument('--research', choices=['l2sp','sam','contrast','consistency','swa'], required=True)
+    args = ap.parse_args()
+    if args.research == 'swa' and args.resume != 'none':
+        ap.error('SWA requires --resume none until averaging state supports resume')
+
+    if args.official_crops:
+        args.crop_size = 32
+        args.no_aug = True
+
+    if args.fixed_crops and args.crop_size not in (32, 64):
+        ap.error("--fixed_crops requires --crop_size 32 or 64")
+
+    out_dir = (Path(args.out_dir) if args.out_dir else
+               C.EXP_ROOT / "checkpoints" / "finetune_v2" / args.tag)
+
+    rank, world, local_rank, device = setup_distributed()
+
+    # Seed BEFORE model creation so all ranks build identical weights...
+    torch.backends.cuda.matmul.allow_tf32 = True
+    torch.backends.cudnn.allow_tf32 = True
+    torch.set_num_threads(min(8, os.cpu_count() or 1))
+    torch.manual_seed(args.seed)
+    torch.cuda.manual_seed_all(args.seed)
+
+    train_ids = train_patch_ids()
+    val_ids   = val_patch_ids()
+
+    train_ds = PASTISPatchDataset(train_ids)
+    val_ds   = PASTISPatchDataset(val_ids)
+
+    sampler = (DistributedSampler(train_ds, num_replicas=world, rank=rank,
+                                  shuffle=True)
+               if world > 1 else None)
+    train_dl = DataLoader(
+        train_ds, batch_size=args.batch, sampler=sampler,
+        shuffle=(sampler is None), num_workers=2, pin_memory=True,
+        persistent_workers=True, collate_fn=pad_collate)
+    val_dl = DataLoader(
+        val_ds, batch_size=args.batch, shuffle=False,
+        num_workers=2, pin_memory=True, collate_fn=pad_collate)
+
+    n_crops = len(C.FT_CROP_IJ) if (args.official_crops or args.fixed_crops) else args.crops_per_patch
+    steps_per_epoch = len(train_dl) * n_crops
+    total_steps = steps_per_epoch * args.epochs
+    warmup_steps = int(args.warmup_epochs * steps_per_epoch)
+
+    if rank == 0:
+        print(f"[FT-v2] train={len(train_ids)} patches ({len(set(train_ids))} unique)  "
+              f"val={len(val_ids)} patches ({len(set(val_ids))} unique)", flush=True)
+        print(f"[FT-v2] world={world}  batch={args.batch} patches x {n_crops} crops "
+              f"-> {steps_per_epoch} steps/epoch/rank", flush=True)
+        print(f"[FT-v2] crop_size={args.crop_size} "
+              f"({'fixed diagonal' if (args.official_crops or args.fixed_crops) else 'RANDOM'})  "
+              f"aug={'off' if args.no_aug else 'dihedral+temporal+spectral'}",
+              flush=True)
+        print(f"[FT-v2] base_lr={args.base_lr}  enc_mult={args.encoder_lr_mult}  "
+              f"wd={args.wd}  ls={args.label_smoothing}  ema={args.ema_decay}  "
+              f"warmup_ep={args.warmup_epochs}  min_lr_ratio={args.min_lr_ratio}  "
+              f"patience={args.patience}", flush=True)
+        print(f"[FT-v2] seed={args.seed}  epochs={args.epochs}  "
+              f"checkpoints -> {out_dir}", flush=True)
+
+    # ---- model + pretrained encoder ----------------------------------------
+    encoder = UTAE_ASPP(
+        n_channels=C.N_CHANNELS, d_model=C.D_MODEL, n_heads=C.N_HEADS,
+        T_pad=C.T_PAD, windows=C.TSE_WINDOWS, shifts=C.TSE_SHIFTS)
+    if rank == 0:
+        print(f"[FT-v2] loading encoder: {args.pretrain_pth}", flush=True)
+    ckpt = torch.load(args.pretrain_pth, map_location="cpu", weights_only=False)
+    sd = ckpt["model_state_dict"]
+    if not any(k.startswith("spatial_encoder.") for k in sd):
+        # full pretrain graph (latest.tar) -> strip the "utae." prefix
+        sd = {k[len("utae."):]: v for k, v in sd.items() if k.startswith("utae.")}
+        if rank == 0:
+            print("[FT-v2] (extracted encoder weights from full pretrain "
+                  "checkpoint)", flush=True)
+    encoder.load_state_dict(sd, strict=True)
+    anchor = {n: p.detach().clone().to(device) for n,p in encoder.named_parameters()}
+
+    network = UTAEClassificationDual(
+        encoder, d_model=C.D_MODEL, num_classes=C.N_CLASSES).to(device)
+    net_ref = network
+    if world > 1:
+        network = DDP(network, device_ids=[local_rank])
+        net_ref = network.module
+
+    # ...and only AFTER model construction diverge the per-rank RNGs used for
+    # shuffling/augmentation, so the two GPUs see different crops/transforms.
+    torch.manual_seed(args.seed + 1000 * rank)
+    random.seed(args.seed + 1000 * rank)
+
+    if args.init_finetuned:
+        initial = torch.load(args.init_finetuned, map_location="cpu", weights_only=False)
+        net_ref.load_state_dict(initial["model_state_dict"], strict=True)
+        if rank == 0:
+            print(f"[INIT] fine-tuned weights from {args.init_finetuned}; optimizer/schedule start fresh", flush=True)
+
+    # ---- losses: uniform weights (inv-freq was a catastrophic regression) ---
+    class_weights = torch.ones(C.N_CLASSES, device=device)
+    class_weights[0] = 0.0
+    class_weights[C.N_CLASSES - 1] = 0.0
+
+    ce_loss = nn.CrossEntropyLoss(weight=class_weights,
+                                  label_smoothing=args.label_smoothing)
+    if args.mask_ce_invalid:
+        def masked_ce(logits, target):
+            valid = (target > 0) & (target < C.N_CLASSES - 1)
+            if not valid.any():
+                return logits.sum() * 0.0
+            return torch.nn.functional.cross_entropy(
+                logits.permute(0, 2, 3, 1)[valid], target[valid],
+                weight=class_weights, label_smoothing=args.label_smoothing)
+        ce_loss = masked_ce
+    lovasz_loss = LovaszSoftmaxLoss(ignore_indices=[0, C.N_CLASSES - 1])
+    bce_loss = nn.BCEWithLogitsLoss()
+
+    # ---- optimizer / EMA ----------------------------------------------------
+    optimizer = torch.optim.AdamW(
+        build_param_groups(net_ref, args.base_lr, args.encoder_lr_mult,
+                           args.wd),
+        lr=args.base_lr, betas=(0.9, 0.95))
+    scaler = GradScaler()
+    ema = ModelEMA(network, decay=args.ema_decay)
+    from research_methods import pixel_contrast
+    features = {}
+    if args.research == 'contrast':
+        net_ref.sta.register_forward_hook(lambda module, inputs, output: features.update(value=output))
+    swa = torch.optim.swa_utils.AveragedModel(net_ref) if args.research == 'swa' else None
+    best_swa = -1.0
+
+    def training_loss(x, positions, target, boundary):
+        with autocast(dtype=torch.bfloat16 if args.research == 'contrast' else torch.float16):
+            outputs = network(x, positions)
+        sem = outputs['sem_logits'].float()
+        refined = outputs['refined_logits'].float()
+        loss = (ce_loss(sem,target) + .75*lovasz_loss(sem,target)
+                + ce_loss(refined,target) + .75*lovasz_loss(refined,target)
+                + args.boundary_weight*bce_loss(outputs['bnd_logits'].float().squeeze(1),boundary))
+        if args.research == 'l2sp':
+            # Sum of squared distance, encoder only; original pretrained anchor.
+            loss = loss + .001*sum((p-anchor[n]).square().sum() for n,p in net_ref.utae.named_parameters())
+        elif args.research == 'contrast':
+            loss = loss + .05*pixel_contrast(features['value'], target)
+        elif args.research == 'consistency' and epoch >= 3:
+            with torch.no_grad(), autocast():
+                teacher = ema.module(aug_spectral(x, gain_std=.02, bias_std=.01, noise_std=.005),positions)['refined_logits'].float().softmax(1)
+            valid = (target>0)&(target<C.N_CLASSES-1)&(teacher.max(1).values>=.8)
+            if valid.any():
+                kl = torch.nn.functional.kl_div(refined.log_softmax(1),teacher,reduction='none').sum(1)
+                loss = loss + .1*min(1.,(epoch-2)/5)*kl[valid].mean()
+        return loss
+
+    if rank == 0:
+        n_params = sum(p.numel() for p in network.parameters() if p.requires_grad)
+        n_enc = sum(p.numel() for n_, p in net_ref.named_parameters()
+                    if n_.startswith("utae."))
+        print(f"[FT-v2] params={n_params/1e6:.2f}M  (encoder {n_enc/1e6:.2f}M)",
+              flush=True)
+
+    # ---- resume --------------------------------------------------------------
+    os.makedirs(out_dir, exist_ok=True)
+    latest_path = out_dir / "latest.tar"
+    start_epoch, best_raw, best_ema = 0, {"miou": -1.0}, {"miou": -1.0}
+    best_monitor, patience_counter, history = -1.0, 0, []
+
+    resume_from = None
+    if args.resume == "auto":
+        resume_from = latest_path if latest_path.is_file() else None
+    elif args.resume not in ("none", ""):
+        resume_from = Path(args.resume)
+        if not resume_from.is_file():
+            raise FileNotFoundError(f"--resume: no such file {resume_from}")
+
+    if resume_from is not None:
+        ck = torch.load(resume_from, map_location="cpu", weights_only=False)
+        net_ref.load_state_dict(ck["model_state_dict"])
+        ema.module.load_state_dict(ck["ema_state_dict"])
+        ema.updates = ck.get("ema_updates", 0)
+        optimizer.load_state_dict(ck["optimizer_state_dict"])
+        scaler.load_state_dict(ck["scaler_state_dict"])
+        best_raw = ck["best_raw"]; best_ema = ck["best_ema"]
+        best_monitor = ck.get("best_monitor", -1.0)
+        patience_counter = ck.get("patience_counter", 0)
+        history = ck.get("history", [])
+        start_epoch = int(ck["epoch"]) + 1
+        if rank == 0:
+            print(f"[FT-v2] RESUMED from {resume_from} (finished epoch "
+                  f"{ck['epoch']}) -> epoch {start_epoch}/{args.epochs}",
+                  flush=True)
+        if start_epoch >= args.epochs:
+            print("[FT-v2] already complete; nothing to do.", flush=True)
+            cleanup_distributed()
+            return
+    elif rank == 0:
+        print(f"[FT-v2] starting fresh (--resume={args.resume})", flush=True)
+
+    if rank == 0:
+        print(f"[HYPOTHESIS] temporal_aug={not args.no_temporal_aug} "
+              f"mask_ce_invalid={args.mask_ce_invalid} boundary_weight={args.boundary_weight} "
+              f"ema_decay={args.ema_decay}", flush=True)
+    if args.init_finetuned and start_epoch == 0:
+        m_init = validate(net_ref, val_dl, device, args.crop_size, args.limit_batches)
+        if rank == 0:
+            with open(out_dir / "initial_metrics.json", "w") as f:
+                json.dump(m_init, f, indent=2)
+            print(f"[INITIAL] mIoU={m_init['miou']:.6f}", flush=True)
+
+    # ---- training loop -------------------------------------------------------
+    gstep = start_epoch * steps_per_epoch
+    hi = C.PATCH_SIZE - args.crop_size
+
+    for epoch in range(start_epoch, args.epochs):
+        if sampler is not None:
+            sampler.set_epoch(epoch)
+        network.train()
+        frozen = epoch < args.freeze_encoder_epochs
+        for parameter in net_ref.utae.parameters():
+            parameter.requires_grad_(not frozen)
+        if frozen:
+            net_ref.utae.eval()  # freeze BatchNorm statistics and encoder dropout
+        if rank == 0:
+            print(f"[ENCODER] frozen={frozen}", flush=True)
+        ep_start = time.time()
+        ep_loss, n_steps = 0.0, 0
+        stop_flag = False
+
+        for it, ((xp, pos, _days), yp) in enumerate(train_dl):
+            if args.limit_batches and it >= args.limit_batches:
+                break
+            xp  = xp.to(device, non_blocking=True)      # (B,T,10,128,128)
+            pos = pos.to(device, non_blocking=True)
+            yp  = yp.to(device, non_blocking=True)      # (B,128,128)
+
+            if args.official_crops or args.fixed_crops:
+                crop_list = [crop_ij(xp, yp, i, j, C.PATCH_SIZE // args.crop_size)
+                             for (i, j) in [tuple(x) for x in C.FT_CROP_IJ]]
+            else:
+                crop_list = []
+                for _ in range(n_crops):
+                    i = int(torch.randint(0, hi + 1, ()))
+                    j = int(torch.randint(0, hi + 1, ()))
+                    crop_list.append(
+                        (xp[:, :, :, i:i + args.crop_size,
+                              j:j + args.crop_size],
+                         yp[:, i:i + args.crop_size, j:j + args.crop_size]))
+
+            for xc, yc in crop_list:
+                pos_c = pos
+                if not args.no_aug:
+                    xc, yc = aug_dihedral(xc, yc)
+                    if not args.no_temporal_aug:
+                        xc, pos_c = aug_temporal_subsample(xc, pos_c)
+                        xc = aug_frame_dropout(xc)
+                    xc = aug_spectral(xc)
+                bnd_gt = compute_boundary_target(yc)
+
+                optimizer.zero_grad(set_to_none=True)
+                loss = training_loss(xc,pos_c,yc,bnd_gt)
+                if not torch.isfinite(loss):
+                    raise RuntimeError('Nonfinite research loss')
+                scaler.scale(loss).backward()
+                if args.research == 'sam':
+                    parameters = [p for p in net_ref.parameters() if p.grad is not None]
+                    norm = torch.linalg.vector_norm(torch.stack([p.grad.float().norm()/scaler.get_scale() for p in parameters]))
+                    if not torch.isfinite(norm):
+                        # AMP overflow: let GradScaler skip this update and lower
+                        # its scale before the next crop. No SAM perturbation made.
+                        scaler.unscale_(optimizer)
+                        scaler.step(optimizer)
+                        scaler.update()
+                        optimizer.zero_grad(set_to_none=True)
+                        print('[SAM AMP] skipped overflowing first pass; scale=', scaler.get_scale(), flush=True)
+                        continue
+                    offsets = []
+                    with torch.no_grad():
+                        for parameter in parameters:
+                            offset = parameter.grad / scaler.get_scale() * (.02/(norm+1e-12))
+                            parameter.add_(offset)
+                            offsets.append(offset)
+                    optimizer.zero_grad(set_to_none=True)
+                    bn = [m for m in net_ref.modules() if isinstance(m, torch.nn.modules.batchnorm._BatchNorm)]
+                    states = [m.training for m in bn]
+                    for m in bn: m.eval()
+                    try:
+                        second_loss = training_loss(xc,pos_c,yc,bnd_gt)
+                        scaler.scale(second_loss).backward()
+                    finally:
+                        with torch.no_grad():
+                            for parameter,offset in zip(parameters,offsets): parameter.sub_(offset)
+                        for m,state in zip(bn,states): m.train(state)
+                scaler.unscale_(optimizer)
+                torch.nn.utils.clip_grad_norm_(network.parameters(),max_norm=5.0)
+                factor = 1.0 if args.research == 'swa' else lr_factor(gstep,total_steps,warmup_steps,args.min_lr_ratio)
+                set_lrs(optimizer,factor)
+                scaler.step(optimizer)
+                scaler.update()
+                ema.update(network)
+                gstep += 1
+
+                ep_loss += loss.item()
+                n_steps += 1
+
+            if rank == 0 and it % 10 == 0:
+                print(f"  ep {epoch:3d} batch {it:3d}/{len(train_dl)}  "
+                      f"step {n_steps:3d}/{steps_per_epoch}  "
+                      f"loss={loss.item():.4f}  "
+                      f"lr={optimizer.param_groups[-1]['lr']:.2e}  "
+                      f"t={time.time()-ep_start:.0f}s", flush=True)
+
+        if swa is not None and epoch >= 5:
+            swa.update_parameters(net_ref)
+            # Calibrate BN only on the same two fixed training crops. Dropout off.
+            swa.module.eval()
+            bn = [m for m in swa.module.modules() if isinstance(m, torch.nn.modules.batchnorm._BatchNorm)]
+            momenta = [m.momentum for m in bn]
+            for m in bn:
+                m.reset_running_stats(); m.momentum = None; m.train()
+            with torch.no_grad():
+                for bi, ((xx,pp,_), yy) in enumerate(train_dl):
+                    if args.limit_batches and bi >= args.limit_batches: break
+                    xx,pp,yy = xx.to(device),pp.to(device),yy.to(device)
+                    for i,j in C.FT_CROP_IJ:
+                        crop,_ = crop_ij(xx,yy,i,j,C.PATCH_SIZE//args.crop_size)
+                        with autocast(): swa.module(crop,pp)
+            for m,momentum in zip(bn,momenta): m.momentum=momentum; m.eval()
+
+        # ---- validation: raw + EMA ------------------------------------------
+        if rank == 0:
+            m_raw = validate(net_ref, val_dl, device, args.crop_size,
+                             args.limit_batches)
+            m_ema = validate(ema.module, val_dl, device, args.crop_size,
+                             args.limit_batches)
+            m_swa = validate(swa.module,val_dl,device,args.crop_size,args.limit_batches) if swa is not None and epoch >= 5 else None
+            if m_swa is not None and m_swa['miou'] > best_swa:
+                best_swa = m_swa['miou']
+                torch.save(pack_checkpoint(swa.module.state_dict(),epoch,m_swa,args.seed,'swa'),out_dir/'model_best_swa.tar')
+            ep_sec = time.time() - ep_start
+            mean_loss = ep_loss / max(n_steps, 1)
+
+            history.append({
+                "epoch": epoch, "train_loss": mean_loss,
+                "lr": optimizer.param_groups[-1]["lr"],
+                "raw": {k: m_raw[k] for k in ("miou", "oa", "mf1", "kappa")},
+                "ema": {k: m_ema[k] for k in ("miou", "oa", "mf1", "kappa")},
+                "epoch_sec": ep_sec, "swa": m_swa, "research": args.research,
+            })
+            with open(out_dir / "history.json", "w") as f:
+                json.dump(history, f, indent=1)
+
+            improved = False
+            if m_raw["miou"] > best_raw["miou"]:
+                best_raw = {"miou": m_raw["miou"], "epoch": epoch}
+                torch.save(pack_checkpoint(net_ref.state_dict(), epoch,
+                                           m_raw, args.seed, "raw"),
+                           out_dir / "model_best_raw.tar")
+                improved = True
+            if m_ema["miou"] > best_ema["miou"]:
+                best_ema = {"miou": m_ema["miou"], "epoch": epoch}
+                torch.save(pack_checkpoint(ema.module.state_dict(), epoch,
+                                           m_ema, args.seed, "ema"),
+                           out_dir / "model_best_ema.tar")
+                improved = True
+
+            monitor = max(m_raw["miou"], m_ema["miou"])
+            if monitor > best_monitor:
+                best_monitor = monitor
+                patience_counter = 0
+            else:
+                patience_counter += 1
+
+            print(f"[ep {epoch:3d} DONE] loss={mean_loss:.4f}  "
+                  f"raw_mIoU={m_raw['miou']:.4f}  ema_mIoU={m_ema['miou']:.4f}  "
+                  f"best_raw={best_raw['miou']:.4f}@{best_raw['epoch']}  "
+                  f"best_ema={best_ema['miou']:.4f}@{best_ema['epoch']}  "
+                  f"patience={patience_counter}/{args.patience}  "
+                  f"t={ep_sec:.0f}s", flush=True)
+            if improved or (epoch % args.print_every == 0):
+                print_metrics(m_raw, f"ep {epoch} RAW")
+                print_metrics(m_ema, f"ep {epoch} EMA")
+
+            # resumable latest.tar every epoch
+            tmp = out_dir / "latest.tar.tmp"
+            torch.save({
+                "epoch": epoch,
+                "model_state_dict": net_ref.state_dict(),
+                "ema_state_dict": ema.module.state_dict(),
+                "ema_updates": ema.updates,
+                "optimizer_state_dict": optimizer.state_dict(),
+                "scaler_state_dict": scaler.state_dict(),
+                "best_raw": best_raw, "best_ema": best_ema,
+                "best_monitor": best_monitor,
+                "patience_counter": patience_counter,
+                "history": history,
+                "args": vars(args),
+            }, tmp)
+            os.replace(tmp, latest_path)
+
+            if args.patience > 0 and patience_counter >= args.patience:
+                print(f"[EARLY STOP] best_raw={best_raw}  best_ema={best_ema}",
+                      flush=True)
+                stop_flag = True
+
+        # keep ranks in step and share rank 0's early-stop decision
+        if world > 1:
+            flag = torch.tensor([1 if stop_flag else 0], device=device)
+            dist.broadcast(flag, src=0)
+            stop_flag = bool(flag.item())
+        if stop_flag:
+            break
+
+    if rank == 0:
+        print(f"\n[FT-v2 COMPLETE]  best_raw={best_raw}  best_ema={best_ema}",
+              flush=True)
+        print(f"[FT-v2] checkpoints in {out_dir}", flush=True)
+    cleanup_distributed()
+
+
+if __name__ == "__main__":
+    main()

main_method/code/train_temporal_cnn.py

@@ -0,0 +1,76 @@
+"""Replay final temporal CNN training, preserving the scored loss/augmentation/RNG logic."""
+import argparse,json,random,time
+from pathlib import Path
+import numpy as np
+import torch
+from torch.utils.data import DataLoader
+import config as C
+from dataset import PASTISPatchDataset,train_patch_ids,val_patch_ids,crop_ij,pad_collate
+from temporal_cnn import make_model
+from training_feature_clusters import metrics_cm
+from augmentation import aug_dihedral,aug_temporal_subsample,aug_frame_dropout,aug_spectral,lr_factor
+OUT=Path(__file__).resolve().parents[1]/"runs"
+CEREALS=[2,3,4,6,10,11,17,18]
+def write_json(path,data):
+    path.parent.mkdir(parents=True,exist_ok=True);path.write_text(json.dumps(data,indent=2))
+
+def loader(ids,batch,shuffle=False):
+    return DataLoader(PASTISPatchDataset(ids),batch_size=batch,shuffle=shuffle,num_workers=2,pin_memory=True,persistent_workers=True,collate_fn=pad_collate)
+
+
+def target_for(y,classes):
+    target=torch.full_like(y,-100)
+    for i,c in enumerate(classes):target[y==c]=i
+    return target
+
+
+@torch.inference_mode()
+def validate(model,dl,classes):
+    model.eval();cm=np.zeros((20,20),np.int64)
+    for (x,pos,_),y in dl:
+        x,pos=x.cuda(),pos.cuda()
+        for i,j in C.FT_CROP_IJ:
+            xc,yc=crop_ij(x,y,i,j,4)
+            with torch.autocast('cuda',dtype=torch.float16):pred=model(xc,pos).argmax(1)
+            pred=np.array(classes)[pred.cpu().numpy().ravel()];gt=yc.numpy().ravel()
+            valid=np.isin(gt,classes);cm+=np.bincount(20*gt[valid]+pred[valid],minlength=400).reshape(20,20)
+    result=metrics_cm(cm)
+    if len(classes)<18:result['selection_score']=float(np.array(result['per_class_iou'])[np.array(classes)-1].mean())
+    else:result['selection_score']=result['miou']
+    return result
+
+
+def train(args):
+    classes=CEREALS if args.kind=='cereal' else list(range(1,19))
+    folder=OUT/f'32X32_{args.kind}_seed{args.seed}';folder.mkdir(parents=True,exist_ok=True)
+    model=make_model(args.kind,len(classes)).cuda();optimizer=torch.optim.AdamW(model.parameters(),lr=1e-3,weight_decay=.01)
+    torch.manual_seed(args.seed);random.seed(args.seed)
+    scaler=torch.amp.GradScaler('cuda');td=loader(train_patch_ids(),2,True);vd=loader(val_patch_ids(),2)
+    start=0;best=-1.
+    if (folder/'latest.tar').exists():
+        ck=torch.load(folder/'latest.tar',weights_only=False);model.load_state_dict(ck['state']);optimizer.load_state_dict(ck['optimizer']);scaler.load_state_dict(ck['scaler']);start=ck['epoch']+1;best=ck['best'];torch.set_rng_state(ck['rng']);torch.cuda.set_rng_state_all(ck['cuda_rng']);random.setstate(ck['python_rng'])
+    for epoch in range(start,args.epochs):
+        model.train();started=time.monotonic();total=0.;steps=0
+        for (x,pos,_),y in td:
+            x,pos,y=x.cuda(),pos.cuda(),y.cuda()
+            for i,j in C.FT_CROP_IJ:
+                xc,yc=crop_ij(x,y,i,j,4);xc,yc=aug_dihedral(xc,yc);xc,pc=aug_temporal_subsample(xc,pos);xc=aug_frame_dropout(xc);xc=aug_spectral(xc)
+                target=target_for(yc,classes);optimizer.zero_grad(set_to_none=True)
+                factor=lr_factor(epoch*76+steps,args.epochs*76,3*76,.01)
+                for g in optimizer.param_groups:g['lr']=1e-3*factor
+                with torch.autocast('cuda',dtype=torch.float16):logits=model(xc,pc)
+                loss=torch.nn.functional.cross_entropy(logits.float(),target,ignore_index=-100,label_smoothing=.05) if (target!=-100).any() else logits.float().sum()*0
+                if not torch.isfinite(loss):raise RuntimeError('Nonfinite specialist loss')
+                scaler.scale(loss).backward();scaler.unscale_(optimizer);torch.nn.utils.clip_grad_norm_(model.parameters(),1.);scaler.step(optimizer);scaler.update();total+=loss.item();steps+=1
+        assert steps==76
+        metric=validate(model,vd,classes)
+        if metric['selection_score']>best:
+            best=metric['selection_score'];torch.save({'state':model.state_dict(),'classes':classes,'kind':args.kind,'seed':args.seed,'epoch':epoch,'validation':metric},folder/'best.tar')
+        torch.save({'state':model.state_dict(),'optimizer':optimizer.state_dict(),'scaler':scaler.state_dict(),'epoch':epoch,'best':best,'rng':torch.get_rng_state(),'cuda_rng':torch.cuda.get_rng_state_all(),'python_rng':random.getstate()},folder/'latest.tar')
+        write_json(folder/'progress.json',{'epoch_completed':epoch+1,'epochs':args.epochs,'best_selection_score':best,'seconds_per_epoch':time.monotonic()-started})
+        print('epoch',epoch+1,'loss',total/steps,'selection',metric['selection_score'],'best',best,'seconds',time.monotonic()-started,flush=True)
+
+
+if __name__=='__main__':
+    ap=argparse.ArgumentParser();ap.add_argument('--kind',choices=['cnn_control','attention'],default='cnn_control');ap.add_argument('--seed',type=int,default=3407);ap.add_argument('--epochs',type=int,default=100);args=ap.parse_args()
+    torch.set_num_threads(4);torch.manual_seed(args.seed);random.seed(args.seed);np.random.seed(args.seed);torch.backends.cuda.matmul.allow_tf32=True;torch.backends.cudnn.allow_tf32=True;train(args)

main_method/code/training_feature_clusters.py

@@ -0,0 +1,81 @@
+"""Prototype (three training-feature cluster centres per class) readout and metrics. Extracted unchanged from the scored implementation."""
+import numpy as np
+import torch
+import torch.nn.functional as F
+from temporal_cnn import valid_from_index_positions
+
+def metrics_cm(cm):
+    tp = np.diag(cm)[1:19].astype(float)
+    gt, pp = cm.sum(1)[1:19], cm.sum(0)[1:19]
+    iou = tp / np.maximum(gt + pp - tp, 1)
+    f1 = 2 * tp / np.maximum(gt + pp, 1)
+    total = cm.sum()
+    oa = cm.trace() / max(total, 1)
+    chance = np.dot(cm.sum(0).astype(float), cm.sum(1)) / max(total ** 2, 1)
+    return {'miou': float(iou.mean()), 'oa': float(oa),
+            'macro_f1': float(f1.mean()), 'kappa': float((oa-chance)/max(1-chance,1e-12)),
+            'per_class_iou': iou.tolist(), 'confusion_matrix': cm.tolist()}
+
+
+class DepthCollector:
+    def __init__(self, encoder):
+        self.handles = [block.register_forward_hook(self.hook(i))
+                        for i, block in enumerate(encoder.temporal_encoder.blocks)]
+
+    def begin(self, x, pos):
+        b, _, _, h, w = x.shape
+        self.shape = b, h, w
+        self.valid = valid_from_index_positions(pos)[:, None, None]
+        self.valid = self.valid.expand(b, h, w, -1).reshape(b*h*w, -1)
+        self.parts = [[], [], []]
+        self.offsets = [0, 0, 0]
+
+    def hook(self, depth):
+        def collect(module, inputs, output):
+            start = self.offsets[depth]
+            valid = self.valid[start:start + output.shape[0]]
+            if valid.shape[1] < output.shape[1]:
+                valid = F.pad(valid, (0, output.shape[1]-valid.shape[1]), value=False)
+            weights = valid[..., None].float()
+            values = output.float()
+            count = weights.sum(1).clamp_min(1)
+            mean = (values * weights).sum(1) / count
+            var = ((values - mean[:, None]).square() * weights).sum(1) / count
+            summary = torch.cat((mean, var.clamp_min(0).sqrt()), -1)
+            self.parts[depth].append(summary.detach().half().cpu().numpy())
+            self.offsets[depth] += len(output)
+        return collect
+
+    def end(self):
+        assert self.offsets == [np.prod(self.shape)] * 3
+        return np.stack([np.concatenate(parts) for parts in self.parts], axis=1)
+
+    def close(self):
+        for handle in self.handles:
+            handle.remove()
+
+
+def rows(features, indices, depth):
+    data = np.asarray(features[indices])
+    return (data[:,depth,:] if depth>=0 else data.reshape(len(data),-1)).astype(np.float32)
+
+
+def normalized(features, indices, depth, mean, std):
+    return (torch.from_numpy(rows(features,indices,depth)).cuda()-mean)/std
+
+
+def probability(features, depth, mean, std, kind, state):
+    out=np.zeros((len(features),20),np.float32)
+    with torch.inference_mode():
+        for start in range(0,len(features),4096):
+            ix=np.arange(start,min(start+4096,len(features)))
+            x=normalized(features,ix,depth,mean,std)
+            if kind=='linear':
+                logits=F.linear(x,state['weight'],state['bias'])
+            else:
+                embeddings=F.normalize(x,dim=-1)
+                logits=torch.einsum('nd,ckd->nck',embeddings,state)/.1
+                logits=logits.logsumexp(-1)-np.log(3)
+            out[start:start+len(ix),1:19]=logits.softmax(-1).cpu().numpy()
+    return out
+

main_method/configurations/32X32_highest_observed_test_seed3407/manifest.json

@@ -0,0 +1,25 @@
+{
+  "name": "highest_observed_test",
+  "seed": 3407,
+  "addition_kind": "attention",
+  "addition_alpha": 0.1,
+  "sam_checkpoint": "sam_network_seed3407.tar",
+  "feature_cluster_checkpoint": "training_feature_cluster_centres_seed3407.tar",
+  "original_cnn_checkpoint": "original_temporal_cnn_seed3407.tar",
+  "addition_checkpoint": "attention_temporal_cnn_seed3407.tar",
+  "shared_checkpoint_directory": "../../checkpoints/shared",
+  "selection": "validation_miou",
+  "weights": {
+    "sam": 0.3375,
+    "training_feature_cluster_centres": 0.3375,
+    "original_cnn": 0.225,
+    "addition": 0.1
+  },
+  "sha256": {
+    "sam_network_seed3407.tar": "aa834986f0756f8bcf5646f3af63d0ccbd59ad46d33f6a64641e98fe14e679f1",
+    "training_feature_cluster_centres_seed3407.tar": "3a17469c8d41370e6808f00c24fc49f8801c88a9e4715b5a19802bba9ec3fb30",
+    "original_temporal_cnn_seed3407.tar": "08ba0ec1c2409596301504f299c40b8eb20346c12241903364d74179b23a1774",
+    "new_temporal_cnn_seed3407.tar": "a08c3485199d8b519bf1a9dad72c84545b7adee818798acdfe068135be3de833",
+    "attention_temporal_cnn_seed3407.tar": "de57690bdbae4ff182b983429e1b6c2683a9ad1fc7bfe9011a7a3cfc24f53bf3"
+  }
+}

main_method/configurations/32X32_highest_observed_test_seed3407/selection.json

@@ -0,0 +1,4691 @@
+{
+  "kind": "attention",
+  "seed": 3407,
+  "mode": "add",
+  "alpha": 0.1,
+  "metrics": {
+    "miou": 0.5183677267400687,
+    "oa": 0.7884448538468953,
+    "macro_f1": 0.6324601460087027,
+    "kappa": 0.7649973719122495,
+    "per_class_iou": [
+      0.7845430753618544,
+      0.8055290753098189,
+      0.8113220293183814,
+      0.5516930022573363,
+      0.8960411972964274,
+      0.5464888191447627,
+      0.6260709914320686,
+      0.688765341445505,
+      0.3864444860513013,
+      0.14764267990074442,
+      0.8423696072118481,
+      0.19387186629526462,
+      0.11464354527938343,
+      0.3333333333333333,
+      0.8420805998125586,
+      0.4998587969500141,
+      0.022342995169082124,
+      0.2375776397515528
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        14689,
+        124,
+        48,
+        31,
+        20,
+        47,
+        4,
+        493,
+        0,
+        3,
+        210,
+        84,
+        3,
+        729,
+        20,
+        266,
+        5,
+        4,
+        0
+      ],
+      [
+        0,
+        96,
+        11830,
+        81,
+        10,
+        16,
+        47,
+        4,
+        0,
+        18,
+        37,
+        186,
+        27,
+        5,
+        98,
+        0,
+        9,
+        5,
+        8,
+        0
+      ],
+      [
+        0,
+        155,
+        130,
+        12010,
+        20,
+        11,
+        2,
+        190,
+        0,
+        33,
+        2,
+        0,
+        2,
+        5,
+        173,
+        124,
+        37,
+        1,
+        973,
+        0
+      ],
+      [
+        0,
+        21,
+        418,
+        31,
+        1222,
+        51,
+        5,
+        0,
+        0,
+        0,
+        226,
+        0,
+        11,
+        7,
+        0,
+        0,
+        19,
+        33,
+        3,
+        0
+      ],
+      [
+        0,
+        68,
+        8,
+        25,
+        0,
+        5568,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        19,
+        10,
+        0,
+        91,
+        0,
+        0
+      ],
+      [
+        0,
+        66,
+        91,
+        3,
+        12,
+        1,
+        1393,
+        31,
+        216,
+        0,
+        2,
+        314,
+        0,
+        0,
+        79,
+        0,
+        5,
+        195,
+        0,
+        0
+      ],
+      [
+        0,
+        5,
+        1,
+        11,
+        0,
+        0,
+        11,
+        4092,
+        358,
+        113,
+        0,
+        12,
+        674,
+        0,
+        77,
+        1,
+        7,
+        0,
+        17,
+        0
+      ],
+      [
+        0,
+        23,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        6566,
+        0,
+        0,
+        8,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        3,
+        21,
+        3,
+        0,
+        1,
+        0,
+        17,
+        0,
+        2064,
+        0,
+        0,
+        32,
+        22,
+        3,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        26,
+        888,
+        0,
+        5,
+        0,
+        0,
+        0,
+        0,
+        5,
+        238,
+        0,
+        0,
+        0,
+        5,
+        0,
+        32,
+        3,
+        0,
+        0
+      ],
+      [
+        0,
+        7,
+        1,
+        0,
+        73,
+        0,
+        18,
+        4,
+        11,
+        0,
+        0,
+        6541,
+        0,
+        0,
+        15,
+        0,
+        66,
+        0,
+        6,
+        0
+      ],
+      [
+        0,
+        116,
+        18,
+        153,
+        1,
+        5,
+        3,
+        433,
+        489,
+        2890,
+        0,
+        120,
+        1392,
+        200,
+        154,
+        14,
+        10,
+        9,
+        39,
+        0
+      ],
+      [
+        0,
+        1,
+        46,
+        51,
+        0,
+        0,
+        0,
+        197,
+        8,
+        37,
+        1,
+        94,
+        216,
+        119,
+        14,
+        4,
+        8,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1021,
+        18,
+        37,
+        0,
+        3,
+        7,
+        52,
+        440,
+        0,
+        0,
+        63,
+        1,
+        0,
+        1670,
+        0,
+        173,
+        19,
+        0,
+        0
+      ],
+      [
+        0,
+        27,
+        6,
+        29,
+        7,
+        6,
+        0,
+        1,
+        0,
+        36,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1797,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        53,
+        0,
+        6,
+        0,
+        0,
+        0,
+        40,
+        920,
+        0,
+        0,
+        8,
+        0,
+        0,
+        32,
+        0,
+        1770,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        241,
+        439,
+        46,
+        9,
+        311,
+        0,
+        0,
+        0,
+        43,
+        139,
+        0,
+        0,
+        0,
+        0,
+        3,
+        27,
+        37,
+        0,
+        0
+      ],
+      [
+        0,
+        14,
+        0,
+        411,
+        0,
+        0,
+        1,
+        184,
+        0,
+        0,
+        0,
+        8,
+        87,
+        0,
+        108,
+        49,
+        52,
+        0,
+        612,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "reference": {
+    "miou": 0.517690746616618,
+    "oa": 0.7853386317627274,
+    "macro_f1": 0.6313043933615895,
+    "kappa": 0.7617504573466095,
+    "per_class_iou": [
+      0.7832551694734599,
+      0.810901842177619,
+      0.7879978325657003,
+      0.5577777777777778,
+      0.8986279257465698,
+      0.580084909301428,
+      0.6166109930154874,
+      0.6909798968529628,
+      0.38513513513513514,
+      0.1546572934973638,
+      0.8519243313763861,
+      0.19663702056698165,
+      0.10965323336457357,
+      0.3287156144864437,
+      0.830249768732655,
+      0.5048543689320388,
+      0.02144607843137255,
+      0.20892424766516776
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        14697,
+        126,
+        50,
+        60,
+        18,
+        47,
+        5,
+        490,
+        0,
+        3,
+        219,
+        87,
+        3,
+        699,
+        21,
+        245,
+        5,
+        5,
+        0
+      ],
+      [
+        0,
+        100,
+        11797,
+        79,
+        11,
+        15,
+        56,
+        3,
+        0,
+        19,
+        59,
+        191,
+        21,
+        8,
+        98,
+        0,
+        7,
+        5,
+        8,
+        0
+      ],
+      [
+        0,
+        165,
+        120,
+        11634,
+        26,
+        11,
+        3,
+        200,
+        1,
+        33,
+        3,
+        0,
+        2,
+        6,
+        215,
+        134,
+        39,
+        1,
+        1275,
+        0
+      ],
+      [
+        0,
+        25,
+        305,
+        30,
+        1255,
+        41,
+        21,
+        0,
+        0,
+        0,
+        300,
+        0,
+        12,
+        9,
+        0,
+        0,
+        22,
+        23,
+        4,
+        0
+      ],
+      [
+        0,
+        71,
+        7,
+        25,
+        0,
+        5567,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        18,
+        9,
+        0,
+        92,
+        0,
+        0
+      ],
+      [
+        0,
+        63,
+        73,
+        4,
+        17,
+        4,
+        1503,
+        26,
+        228,
+        0,
+        2,
+        224,
+        0,
+        0,
+        81,
+        0,
+        4,
+        179,
+        0,
+        0
+      ],
+      [
+        0,
+        4,
+        1,
+        7,
+        0,
+        0,
+        15,
+        4061,
+        338,
+        113,
+        0,
+        10,
+        713,
+        2,
+        82,
+        5,
+        3,
+        0,
+        25,
+        0
+      ],
+      [
+        0,
+        21,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        6565,
+        0,
+        0,
+        11,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        5,
+        21,
+        3,
+        0,
+        1,
+        0,
+        23,
+        0,
+        2052,
+        0,
+        0,
+        24,
+        33,
+        4,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        22,
+        868,
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        5,
+        264,
+        0,
+        0,
+        0,
+        5,
+        0,
+        33,
+        2,
+        0,
+        0
+      ],
+      [
+        0,
+        8,
+        1,
+        0,
+        67,
+        0,
+        26,
+        4,
+        11,
+        0,
+        0,
+        6530,
+        0,
+        0,
+        20,
+        0,
+        67,
+        0,
+        8,
+        0
+      ],
+      [
+        0,
+        114,
+        20,
+        133,
+        1,
+        5,
+        3,
+        450,
+        474,
+        2875,
+        0,
+        101,
+        1415,
+        210,
+        164,
+        25,
+        10,
+        10,
+        36,
+        0
+      ],
+      [
+        0,
+        1,
+        46,
+        49,
+        0,
+        3,
+        0,
+        195,
+        5,
+        39,
+        1,
+        98,
+        212,
+        117,
+        17,
+        4,
+        7,
+        0,
+        2,
+        0
+      ],
+      [
+        0,
+        1033,
+        18,
+        37,
+        0,
+        3,
+        10,
+        54,
+        438,
+        0,
+        0,
+        60,
+        5,
+        0,
+        1661,
+        0,
+        165,
+        20,
+        0,
+        0
+      ],
+      [
+        0,
+        25,
+        10,
+        23,
+        10,
+        7,
+        0,
+        2,
+        0,
+        36,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1795,
+        1,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        56,
+        0,
+        5,
+        0,
+        0,
+        0,
+        48,
+        918,
+        0,
+        0,
+        5,
+        0,
+        0,
+        29,
+        0,
+        1768,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        254,
+        455,
+        30,
+        9,
+        298,
+        0,
+        0,
+        0,
+        42,
+        137,
+        0,
+        0,
+        0,
+        0,
+        4,
+        29,
+        35,
+        2,
+        0
+      ],
+      [
+        0,
+        17,
+        0,
+        421,
+        0,
+        0,
+        1,
+        197,
+        0,
+        0,
+        0,
+        4,
+        74,
+        0,
+        117,
+        51,
+        40,
+        0,
+        604,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "standalone": {
+    "miou": 0.4622728764594472,
+    "oa": 0.7556367219717013,
+    "macro_f1": 0.5851095565648042,
+    "kappa": 0.7288150704360855,
+    "per_class_iou": [
+      0.7623352996306302,
+      0.7557585644371941,
+      0.8030479896238651,
+      0.34434152235199356,
+      0.8693018807778132,
+      0.35746057420137484,
+      0.5780491623610459,
+      0.7065570222895478,
+      0.36595125500181885,
+      0.0,
+      0.7482904975241689,
+      0.1176056338028169,
+      0.16121212121212122,
+      0.3162297824874512,
+      0.6136274123670736,
+      0.3756779307467668,
+      0.15404168784951702,
+      0.29142343960484957
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        13828,
+        137,
+        130,
+        13,
+        47,
+        0,
+        1,
+        563,
+        0,
+        8,
+        299,
+        53,
+        3,
+        996,
+        16,
+        606,
+        52,
+        28,
+        0
+      ],
+      [
+        0,
+        122,
+        11582,
+        143,
+        39,
+        41,
+        14,
+        0,
+        3,
+        19,
+        88,
+        207,
+        31,
+        0,
+        47,
+        6,
+        67,
+        68,
+        0,
+        0
+      ],
+      [
+        0,
+        141,
+        162,
+        12383,
+        2,
+        9,
+        0,
+        242,
+        0,
+        51,
+        35,
+        3,
+        52,
+        10,
+        188,
+        135,
+        56,
+        28,
+        371,
+        0
+      ],
+      [
+        0,
+        30,
+        1006,
+        6,
+        855,
+        60,
+        0,
+        0,
+        0,
+        2,
+        3,
+        0,
+        20,
+        0,
+        4,
+        9,
+        0,
+        52,
+        0,
+        0
+      ],
+      [
+        0,
+        41,
+        27,
+        47,
+        78,
+        5454,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        13,
+        29,
+        2,
+        97,
+        0,
+        0
+      ],
+      [
+        0,
+        103,
+        219,
+        25,
+        19,
+        0,
+        884,
+        34,
+        70,
+        0,
+        21,
+        707,
+        10,
+        0,
+        34,
+        0,
+        12,
+        269,
+        1,
+        0
+      ],
+      [
+        0,
+        9,
+        2,
+        90,
+        0,
+        0,
+        9,
+        3692,
+        428,
+        0,
+        2,
+        41,
+        491,
+        6,
+        166,
+        128,
+        309,
+        0,
+        6,
+        0
+      ],
+      [
+        0,
+        34,
+        0,
+        0,
+        0,
+        0,
+        0,
+        4,
+        6530,
+        0,
+        0,
+        10,
+        0,
+        0,
+        18,
+        0,
+        2,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        2,
+        4,
+        0,
+        0,
+        0,
+        8,
+        11,
+        2012,
+        12,
+        0,
+        51,
+        1,
+        6,
+        55,
+        0,
+        4,
+        0,
+        0
+      ],
+      [
+        0,
+        48,
+        1041,
+        8,
+        31,
+        13,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1,
+        1,
+        0,
+        59,
+        0,
+        0
+      ],
+      [
+        0,
+        0,
+        5,
+        0,
+        141,
+        0,
+        11,
+        12,
+        22,
+        0,
+        0,
+        6347,
+        9,
+        0,
+        64,
+        0,
+        128,
+        0,
+        3,
+        0
+      ],
+      [
+        0,
+        60,
+        32,
+        331,
+        0,
+        0,
+        24,
+        359,
+        309,
+        3167,
+        41,
+        143,
+        835,
+        8,
+        50,
+        218,
+        288,
+        3,
+        178,
+        0
+      ],
+      [
+        0,
+        0,
+        26,
+        94,
+        0,
+        0,
+        0,
+        167,
+        18,
+        24,
+        19,
+        0,
+        205,
+        133,
+        40,
+        12,
+        36,
+        10,
+        12,
+        0
+      ],
+      [
+        0,
+        617,
+        12,
+        43,
+        0,
+        0,
+        7,
+        87,
+        554,
+        2,
+        13,
+        209,
+        0,
+        0,
+        1701,
+        3,
+        242,
+        2,
+        12,
+        0
+      ],
+      [
+        0,
+        27,
+        6,
+        131,
+        0,
+        5,
+        0,
+        3,
+        0,
+        55,
+        0,
+        4,
+        0,
+        1,
+        8,
+        1558,
+        7,
+        22,
+        82,
+        0
+      ],
+      [
+        0,
+        37,
+        0,
+        18,
+        0,
+        0,
+        0,
+        13,
+        643,
+        0,
+        5,
+        87,
+        0,
+        0,
+        217,
+        0,
+        1801,
+        0,
+        8,
+        0
+      ],
+      [
+        0,
+        47,
+        169,
+        170,
+        113,
+        310,
+        0,
+        0,
+        0,
+        12,
+        171,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        303,
+        0,
+        0
+      ],
+      [
+        0,
+        43,
+        2,
+        312,
+        0,
+        0,
+        0,
+        78,
+        23,
+        0,
+        0,
+        30,
+        132,
+        0,
+        23,
+        18,
+        210,
+        6,
+        649,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "records": {
+    "replace:0.0": {
+      "miou": 0.5069881701623682,
+      "oa": 0.775366587761485,
+      "macro_f1": 0.6219409132377508,
+      "kappa": 0.751105731991019,
+      "per_class_iou": [
+        0.7781331627485474,
+        0.8032224168126094,
+        0.7638945508900666,
+        0.4874521480221182,
+        0.9024627349319507,
+        0.5841441441441442,
+        0.58692089974676,
+        0.6966029723991507,
+        0.3621249761131282,
+        0.14381270903010032,
+        0.8547984770907181,
+        0.20548880393227745,
+        0.09766277128547579,
+        0.3258513931888545,
+        0.8012422360248447,
+        0.5073593073593073,
+        0.02595051297525649,
+        0.19866284622731614
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14597,
+          134,
+          59,
+          97,
+          22,
+          60,
+          13,
+          517,
+          2,
+          3,
+          236,
+          93,
+          1,
+          670,
+          34,
+          230,
+          6,
+          6,
+          0
+        ],
+        [
+          0,
+          103,
+          11466,
+          73,
+          93,
+          22,
+          105,
+          5,
+          0,
+          22,
+          170,
+          265,
+          14,
+          18,
+          94,
+          1,
+          10,
+          7,
+          9,
+          0
+        ],
+        [
+          0,
+          165,
+          104,
+          11243,
+          50,
+          13,
+          4,
+          297,
+          7,
+          28,
+          7,
+          0,
+          2,
+          8,
+          245,
+          129,
+          46,
+          2,
+          1518,
+          0
+        ],
+        [
+          0,
+          45,
+          243,
+          34,
+          1146,
+          15,
+          65,
+          0,
+          1,
+          0,
+          431,
+          0,
+          14,
+          3,
+          0,
+          1,
+          34,
+          11,
+          4,
+          0
+        ],
+        [
+          0,
+          65,
+          2,
+          24,
+          0,
+          5570,
+          0,
+          0,
+          2,
+          0,
+          3,
+          0,
+          0,
+          0,
+          17,
+          8,
+          0,
+          98,
+          0,
+          0
+        ],
+        [
+          0,
+          39,
+          61,
+          4,
+          21,
+          4,
+          1621,
+          26,
+          240,
+          0,
+          5,
+          102,
+          2,
+          0,
+          86,
+          0,
+          3,
+          194,
+          0,
+          0
+        ],
+        [
+          0,
+          4,
+          1,
+          4,
+          0,
+          0,
+          15,
+          3940,
+          285,
+          100,
+          0,
+          13,
+          845,
+          6,
+          107,
+          13,
+          3,
+          0,
+          43,
+          0
+        ],
+        [
+          0,
+          11,
+          0,
+          0,
+          0,
+          0,
+          5,
+          0,
+          6562,
+          0,
+          0,
+          17,
+          0,
+          0,
+          2,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          3,
+          20,
+          3,
+          0,
+          1,
+          0,
+          15,
+          0,
+          1895,
+          0,
+          0,
+          26,
+          151,
+          51,
+          1,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          18,
+          826,
+          1,
+          0,
+          1,
+          6,
+          0,
+          0,
+          4,
+          301,
+          0,
+          0,
+          0,
+          5,
+          0,
+          35,
+          5,
+          0,
+          0
+        ],
+        [
+          0,
+          9,
+          2,
+          0,
+          13,
+          0,
+          80,
+          10,
+          15,
+          0,
+          0,
+          6511,
+          0,
+          0,
+          27,
+          0,
+          67,
+          0,
+          8,
+          0
+        ],
+        [
+          0,
+          109,
+          19,
+          109,
+          1,
+          8,
+          7,
+          431,
+          459,
+          2819,
+          0,
+          93,
+          1505,
+          215,
+          168,
+          66,
+          10,
+          10,
+          17,
+          0
+        ],
+        [
+          0,
+          4,
+          33,
+          40,
+          0,
+          5,
+          2,
+          198,
+          5,
+          25,
+          0,
+          92,
+          219,
+          117,
+          30,
+          13,
+          7,
+          1,
+          5,
+          0
+        ],
+        [
+          0,
+          1057,
+          17,
+          37,
+          0,
+          9,
+          15,
+          52,
+          382,
+          0,
+          0,
+          53,
+          16,
+          0,
+          1684,
+          22,
+          132,
+          28,
+          0,
+          0
+        ],
+        [
+          0,
+          18,
+          10,
+          24,
+          13,
+          7,
+          0,
+          2,
+          0,
+          28,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1806,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          52,
+          0,
+          5,
+          0,
+          0,
+          0,
+          71,
+          909,
+          0,
+          0,
+          3,
+          0,
+          0,
+          29,
+          0,
+          1758,
+          0,
+          2,
+          0
+        ],
+        [
+          0,
+          262,
+          324,
+          17,
+          16,
+          276,
+          2,
+          2,
+          0,
+          39,
+          272,
+          0,
+          0,
+          0,
+          2,
+          6,
+          31,
+          43,
+          3,
+          0
+        ],
+        [
+          0,
+          15,
+          2,
+          416,
+          0,
+          0,
+          1,
+          212,
+          0,
+          0,
+          0,
+          1,
+          47,
+          0,
+          131,
+          51,
+          26,
+          0,
+          624,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "replace:0.1": {
+      "miou": 0.5085433172933511,
+      "oa": 0.7776908987692934,
+      "macro_f1": 0.6232419866259026,
+      "kappa": 0.7535763163678348,
+      "per_class_iou": [
+        0.780431762316982,
+        0.808817384036774,
+        0.7690689467969598,
+        0.4876279863481229,
+        0.9005658852061439,
+        0.5766233766233766,
+        0.5950301204819277,
+        0.6947178998623902,
+        0.36710301650540694,
+        0.14515318935208438,
+        0.8552321007081038,
+        0.2048488150367747,
+        0.09930915371329879,
+        0.3300704776820673,
+        0.8128101037437979,
+        0.5015656134358099,
+        0.026994601079784044,
+        0.19780927835051546
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14605,
+          132,
+          56,
+          95,
+          21,
+          59,
+          12,
+          509,
+          2,
+          3,
+          230,
+          91,
+          1,
+          663,
+          32,
+          260,
+          5,
+          4,
+          0
+        ],
+        [
+          0,
+          96,
+          11613,
+          71,
+          64,
+          21,
+          81,
+          5,
+          0,
+          22,
+          131,
+          216,
+          22,
+          13,
+          96,
+          0,
+          9,
+          8,
+          9,
+          0
+        ],
+        [
+          0,
+          167,
+          107,
+          11333,
+          50,
+          12,
+          4,
+          256,
+          6,
+          34,
+          4,
+          0,
+          3,
+          7,
+          223,
+          123,
+          44,
+          3,
+          1492,
+          0
+        ],
+        [
+          0,
+          44,
+          314,
+          34,
+          1143,
+          17,
+          48,
+          0,
+          1,
+          0,
+          383,
+          0,
+          13,
+          3,
+          0,
+          0,
+          32,
+          11,
+          4,
+          0
+        ],
+        [
+          0,
+          64,
+          2,
+          24,
+          0,
+          5570,
+          0,
+          0,
+          1,
+          0,
+          2,
+          0,
+          0,
+          0,
+          17,
+          10,
+          0,
+          99,
+          0,
+          0
+        ],
+        [
+          0,
+          42,
+          64,
+          3,
+          19,
+          3,
+          1554,
+          29,
+          236,
+          0,
+          3,
+          164,
+          0,
+          0,
+          84,
+          0,
+          3,
+          204,
+          0,
+          0
+        ],
+        [
+          0,
+          4,
+          1,
+          4,
+          0,
+          0,
+          14,
+          3951,
+          293,
+          101,
+          0,
+          14,
+          838,
+          2,
+          104,
+          13,
+          4,
+          0,
+          36,
+          0
+        ],
+        [
+          0,
+          12,
+          0,
+          0,
+          0,
+          0,
+          4,
+          0,
+          6563,
+          0,
+          0,
+          17,
+          0,
+          0,
+          1,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          2,
+          19,
+          2,
+          0,
+          1,
+          0,
+          11,
+          0,
+          1935,
+          0,
+          0,
+          29,
+          126,
+          41,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          17,
+          839,
+          1,
+          3,
+          1,
+          3,
+          0,
+          0,
+          4,
+          289,
+          0,
+          0,
+          0,
+          5,
+          0,
+          35,
+          5,
+          0,
+          0
+        ],
+        [
+          0,
+          6,
+          2,
+          0,
+          39,
+          0,
+          52,
+          8,
+          14,
+          0,
+          0,
+          6522,
+          0,
+          0,
+          21,
+          0,
+          70,
+          0,
+          8,
+          0
+        ],
+        [
+          0,
+          110,
+          19,
+          119,
+          1,
+          6,
+          6,
+          421,
+          461,
+          2843,
+          0,
+          96,
+          1504,
+          210,
+          163,
+          47,
+          10,
+          9,
+          21,
+          0
+        ],
+        [
+          0,
+          3,
+          34,
+          40,
+          0,
+          5,
+          2,
+          199,
+          5,
+          24,
+          0,
+          89,
+          231,
+          115,
+          27,
+          12,
+          7,
+          1,
+          2,
+          0
+        ],
+        [
+          0,
+          1036,
+          18,
+          37,
+          0,
+          9,
+          12,
+          53,
+          405,
+          0,
+          0,
+          54,
+          14,
+          0,
+          1686,
+          16,
+          137,
+          27,
+          0,
+          0
+        ],
+        [
+          0,
+          18,
+          10,
+          22,
+          13,
+          7,
+          0,
+          2,
+          0,
+          34,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1802,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          51,
+          0,
+          5,
+          0,
+          0,
+          0,
+          62,
+          918,
+          0,
+          0,
+          3,
+          0,
+          0,
+          28,
+          0,
+          1762,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          247,
+          318,
+          32,
+          13,
+          293,
+          1,
+          2,
+          0,
+          41,
+          263,
+          0,
+          0,
+          0,
+          2,
+          5,
+          31,
+          45,
+          2,
+          0
+        ],
+        [
+          0,
+          15,
+          2,
+          418,
+          0,
+          0,
+          1,
+          201,
+          0,
+          0,
+          0,
+          1,
+          55,
+          0,
+          129,
+          50,
+          40,
+          0,
+          614,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "replace:0.25": {
+      "miou": 0.5106297853457105,
+      "oa": 0.7824252096699906,
+      "macro_f1": 0.6253442262624567,
+      "kappa": 0.758534186028776,
+      "per_class_iou": [
+        0.7830563002680965,
+        0.8082717063818132,
+        0.790556081721012,
+        0.48585111014366567,
+        0.8963797264682221,
+        0.5392953929539296,
+        0.6076452599388379,
+        0.6913437236731256,
+        0.3839638622247318,
+        0.13901601830663615,
+        0.8432181536874678,
+        0.20241486908153575,
+        0.10931558935361217,
+        0.3374924532099014,
+        0.8424497428705002,
+        0.4955431754874652,
+        0.027348394768133173,
+        0.20817457568410114
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14604,
+          134,
+          49,
+          83,
+          19,
+          53,
+          6,
+          504,
+          1,
+          5,
+          215,
+          91,
+          2,
+          674,
+          26,
+          303,
+          6,
+          5,
+          0
+        ],
+        [
+          0,
+          96,
+          11804,
+          80,
+          10,
+          18,
+          55,
+          5,
+          0,
+          23,
+          44,
+          185,
+          32,
+          4,
+          95,
+          0,
+          10,
+          7,
+          9,
+          0
+        ],
+        [
+          0,
+          160,
+          118,
+          11686,
+          28,
+          13,
+          3,
+          225,
+          0,
+          34,
+          2,
+          0,
+          6,
+          4,
+          144,
+          114,
+          42,
+          2,
+          1287,
+          0
+        ],
+        [
+          0,
+          34,
+          517,
+          34,
+          1116,
+          38,
+          15,
+          0,
+          0,
+          0,
+          239,
+          0,
+          10,
+          3,
+          0,
+          0,
+          20,
+          17,
+          4,
+          0
+        ],
+        [
+          0,
+          58,
+          2,
+          23,
+          0,
+          5571,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          19,
+          15,
+          0,
+          100,
+          0,
+          0
+        ],
+        [
+          0,
+          43,
+          71,
+          3,
+          11,
+          0,
+          1393,
+          34,
+          217,
+          0,
+          4,
+          323,
+          0,
+          0,
+          82,
+          0,
+          5,
+          222,
+          0,
+          0
+        ],
+        [
+          0,
+          4,
+          1,
+          6,
+          0,
+          0,
+          13,
+          3974,
+          334,
+          101,
+          0,
+          13,
+          810,
+          0,
+          98,
+          2,
+          5,
+          0,
+          18,
+          0
+        ],
+        [
+          0,
+          15,
+          0,
+          0,
+          0,
+          0,
+          4,
+          0,
+          6565,
+          0,
+          0,
+          13,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          2,
+          19,
+          3,
+          0,
+          1,
+          0,
+          12,
+          0,
+          2040,
+          0,
+          0,
+          32,
+          50,
+          7,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          22,
+          874,
+          0,
+          16,
+          1,
+          2,
+          0,
+          0,
+          4,
+          243,
+          0,
+          0,
+          0,
+          5,
+          0,
+          32,
+          3,
+          0,
+          0
+        ],
+        [
+          0,
+          5,
+          1,
+          0,
+          68,
+          0,
+          16,
+          4,
+          10,
+          0,
+          0,
+          6540,
+          0,
+          0,
+          20,
+          0,
+          70,
+          0,
+          8,
+          0
+        ],
+        [
+          0,
+          111,
+          18,
+          132,
+          1,
+          6,
+          3,
+          391,
+          471,
+          2884,
+          2,
+          125,
+          1492,
+          193,
+          153,
+          14,
+          11,
+          9,
+          30,
+          0
+        ],
+        [
+          0,
+          1,
+          42,
+          42,
+          0,
+          1,
+          0,
+          202,
+          6,
+          19,
+          2,
+          77,
+          256,
+          115,
+          19,
+          7,
+          6,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          1014,
+          16,
+          37,
+          0,
+          6,
+          10,
+          54,
+          444,
+          0,
+          2,
+          56,
+          11,
+          0,
+          1677,
+          2,
+          155,
+          20,
+          0,
+          0
+        ],
+        [
+          0,
+          20,
+          8,
+          22,
+          11,
+          7,
+          0,
+          2,
+          0,
+          36,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1802,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          51,
+          0,
+          6,
+          0,
+          0,
+          0,
+          50,
+          912,
+          0,
+          0,
+          5,
+          0,
+          0,
+          26,
+          0,
+          1779,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          224,
+          304,
+          60,
+          22,
+          316,
+          0,
+          2,
+          0,
+          45,
+          245,
+          0,
+          0,
+          0,
+          0,
+          2,
+          29,
+          46,
+          0,
+          0
+        ],
+        [
+          0,
+          10,
+          2,
+          417,
+          0,
+          0,
+          1,
+          174,
+          0,
+          0,
+          0,
+          2,
+          77,
+          0,
+          123,
+          48,
+          71,
+          0,
+          601,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "replace:0.5": {
+      "miou": 0.5070204304568128,
+      "oa": 0.7870845427962425,
+      "macro_f1": 0.6252589956320188,
+      "kappa": 0.7632795999352977,
+      "per_class_iou": [
+        0.783890511738613,
+        0.787017310252996,
+        0.8440201005025125,
+        0.44506678155967255,
+        0.8781225139220366,
+        0.4521704180064309,
+        0.6280118140836313,
+        0.69839241988715,
+        0.3828197945845005,
+        0.06140350877192982,
+        0.8046345371625786,
+        0.19560741249142072,
+        0.14508928571428573,
+        0.3441103789126853,
+        0.8057944771389769,
+        0.4647164485501668,
+        0.0664756446991404,
+        0.33902439024390246
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14491,
+          132,
+          68,
+          6,
+          28,
+          31,
+          3,
+          534,
+          0,
+          6,
+          251,
+          67,
+          2,
+          754,
+          13,
+          379,
+          8,
+          7,
+          0
+        ],
+        [
+          0,
+          98,
+          11821,
+          94,
+          11,
+          24,
+          29,
+          1,
+          0,
+          19,
+          20,
+          194,
+          37,
+          1,
+          77,
+          0,
+          33,
+          14,
+          4,
+          0
+        ],
+        [
+          0,
+          127,
+          136,
+          12597,
+          8,
+          11,
+          2,
+          230,
+          0,
+          38,
+          4,
+          0,
+          12,
+          0,
+          131,
+          104,
+          29,
+          11,
+          428,
+          0
+        ],
+        [
+          0,
+          30,
+          811,
+          29,
+          1033,
+          57,
+          0,
+          0,
+          0,
+          0,
+          31,
+          0,
+          17,
+          0,
+          0,
+          2,
+          0,
+          37,
+          0,
+          0
+        ],
+        [
+          0,
+          48,
+          3,
+          26,
+          44,
+          5519,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          24,
+          0,
+          106,
+          0,
+          0
+        ],
+        [
+          0,
+          63,
+          135,
+          7,
+          8,
+          0,
+          1125,
+          51,
+          141,
+          0,
+          5,
+          558,
+          0,
+          0,
+          59,
+          0,
+          5,
+          251,
+          0,
+          0
+        ],
+        [
+          0,
+          6,
+          0,
+          25,
+          0,
+          0,
+          5,
+          4040,
+          366,
+          55,
+          0,
+          24,
+          702,
+          0,
+          54,
+          67,
+          30,
+          0,
+          5,
+          0
+        ],
+        [
+          0,
+          23,
+          0,
+          0,
+          0,
+          0,
+          1,
+          1,
+          6560,
+          0,
+          0,
+          8,
+          0,
+          0,
+          3,
+          0,
+          2,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          16,
+          2,
+          0,
+          0,
+          0,
+          18,
+          0,
+          2050,
+          3,
+          0,
+          42,
+          15,
+          7,
+          13,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          32,
+          997,
+          2,
+          23,
+          4,
+          0,
+          0,
+          0,
+          4,
+          91,
+          0,
+          0,
+          0,
+          1,
+          2,
+          31,
+          15,
+          0,
+          0
+        ],
+        [
+          0,
+          1,
+          0,
+          0,
+          95,
+          0,
+          1,
+          3,
+          8,
+          0,
+          0,
+          6528,
+          2,
+          0,
+          23,
+          0,
+          75,
+          0,
+          6,
+          0
+        ],
+        [
+          0,
+          104,
+          14,
+          212,
+          0,
+          3,
+          11,
+          342,
+          425,
+          2965,
+          12,
+          170,
+          1425,
+          82,
+          87,
+          28,
+          95,
+          0,
+          71,
+          0
+        ],
+        [
+          0,
+          0,
+          42,
+          63,
+          0,
+          0,
+          0,
+          213,
+          16,
+          16,
+          4,
+          38,
+          249,
+          130,
+          6,
+          10,
+          8,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          965,
+          12,
+          44,
+          0,
+          2,
+          0,
+          44,
+          461,
+          0,
+          6,
+          82,
+          0,
+          0,
+          1671,
+          0,
+          214,
+          3,
+          0,
+          0
+        ],
+        [
+          0,
+          22,
+          4,
+          43,
+          4,
+          6,
+          0,
+          0,
+          0,
+          42,
+          0,
+          0,
+          0,
+          0,
+          1,
+          1780,
+          0,
+          4,
+          3,
+          0
+        ],
+        [
+          0,
+          42,
+          0,
+          11,
+          0,
+          0,
+          0,
+          28,
+          840,
+          0,
+          2,
+          30,
+          1,
+          0,
+          64,
+          0,
+          1811,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          134,
+          241,
+          117,
+          75,
+          361,
+          0,
+          0,
+          0,
+          50,
+          187,
+          0,
+          0,
+          0,
+          0,
+          0,
+          14,
+          116,
+          0,
+          0
+        ],
+        [
+          0,
+          11,
+          0,
+          314,
+          0,
+          0,
+          0,
+          120,
+          4,
+          0,
+          0,
+          16,
+          110,
+          0,
+          66,
+          37,
+          153,
+          0,
+          695,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "add:0.1": {
+      "miou": 0.5183677267400687,
+      "oa": 0.7884448538468953,
+      "macro_f1": 0.6324601460087027,
+      "kappa": 0.7649973719122495,
+      "per_class_iou": [
+        0.7845430753618544,
+        0.8055290753098189,
+        0.8113220293183814,
+        0.5516930022573363,
+        0.8960411972964274,
+        0.5464888191447627,
+        0.6260709914320686,
+        0.688765341445505,
+        0.3864444860513013,
+        0.14764267990074442,
+        0.8423696072118481,
+        0.19387186629526462,
+        0.11464354527938343,
+        0.3333333333333333,
+        0.8420805998125586,
+        0.4998587969500141,
+        0.022342995169082124,
+        0.2375776397515528
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14689,
+          124,
+          48,
+          31,
+          20,
+          47,
+          4,
+          493,
+          0,
+          3,
+          210,
+          84,
+          3,
+          729,
+          20,
+          266,
+          5,
+          4,
+          0
+        ],
+        [
+          0,
+          96,
+          11830,
+          81,
+          10,
+          16,
+          47,
+          4,
+          0,
+          18,
+          37,
+          186,
+          27,
+          5,
+          98,
+          0,
+          9,
+          5,
+          8,
+          0
+        ],
+        [
+          0,
+          155,
+          130,
+          12010,
+          20,
+          11,
+          2,
+          190,
+          0,
+          33,
+          2,
+          0,
+          2,
+          5,
+          173,
+          124,
+          37,
+          1,
+          973,
+          0
+        ],
+        [
+          0,
+          21,
+          418,
+          31,
+          1222,
+          51,
+          5,
+          0,
+          0,
+          0,
+          226,
+          0,
+          11,
+          7,
+          0,
+          0,
+          19,
+          33,
+          3,
+          0
+        ],
+        [
+          0,
+          68,
+          8,
+          25,
+          0,
+          5568,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          10,
+          0,
+          91,
+          0,
+          0
+        ],
+        [
+          0,
+          66,
+          91,
+          3,
+          12,
+          1,
+          1393,
+          31,
+          216,
+          0,
+          2,
+          314,
+          0,
+          0,
+          79,
+          0,
+          5,
+          195,
+          0,
+          0
+        ],
+        [
+          0,
+          5,
+          1,
+          11,
+          0,
+          0,
+          11,
+          4092,
+          358,
+          113,
+          0,
+          12,
+          674,
+          0,
+          77,
+          1,
+          7,
+          0,
+          17,
+          0
+        ],
+        [
+          0,
+          23,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          6566,
+          0,
+          0,
+          8,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          3,
+          21,
+          3,
+          0,
+          1,
+          0,
+          17,
+          0,
+          2064,
+          0,
+          0,
+          32,
+          22,
+          3,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          26,
+          888,
+          0,
+          5,
+          0,
+          0,
+          0,
+          0,
+          5,
+          238,
+          0,
+          0,
+          0,
+          5,
+          0,
+          32,
+          3,
+          0,
+          0
+        ],
+        [
+          0,
+          7,
+          1,
+          0,
+          73,
+          0,
+          18,
+          4,
+          11,
+          0,
+          0,
+          6541,
+          0,
+          0,
+          15,
+          0,
+          66,
+          0,
+          6,
+          0
+        ],
+        [
+          0,
+          116,
+          18,
+          153,
+          1,
+          5,
+          3,
+          433,
+          489,
+          2890,
+          0,
+          120,
+          1392,
+          200,
+          154,
+          14,
+          10,
+          9,
+          39,
+          0
+        ],
+        [
+          0,
+          1,
+          46,
+          51,
+          0,
+          0,
+          0,
+          197,
+          8,
+          37,
+          1,
+          94,
+          216,
+          119,
+          14,
+          4,
+          8,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          1021,
+          18,
+          37,
+          0,
+          3,
+          7,
+          52,
+          440,
+          0,
+          0,
+          63,
+          1,
+          0,
+          1670,
+          0,
+          173,
+          19,
+          0,
+          0
+        ],
+        [
+          0,
+          27,
+          6,
+          29,
+          7,
+          6,
+          0,
+          1,
+          0,
+          36,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1797,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          53,
+          0,
+          6,
+          0,
+          0,
+          0,
+          40,
+          920,
+          0,
+          0,
+          8,
+          0,
+          0,
+          32,
+          0,
+          1770,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          241,
+          439,
+          46,
+          9,
+          311,
+          0,
+          0,
+          0,
+          43,
+          139,
+          0,
+          0,
+          0,
+          0,
+          3,
+          27,
+          37,
+          0,
+          0
+        ],
+        [
+          0,
+          14,
+          0,
+          411,
+          0,
+          0,
+          1,
+          184,
+          0,
+          0,
+          0,
+          8,
+          87,
+          0,
+          108,
+          49,
+          52,
+          0,
+          612,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "add:0.25": {
+      "miou": 0.5169585217581719,
+      "oa": 0.7914760981566179,
+      "macro_f1": 0.6315085950725178,
+      "kappa": 0.768111401030854,
+      "per_class_iou": [
+        0.7839820118850046,
+        0.7946877724864176,
+        0.8395700369499496,
+        0.5187358916478555,
+        0.8886581469648562,
+        0.512779552715655,
+        0.6400555898702903,
+        0.6927787162162162,
+        0.3855623950755456,
+        0.12156593406593406,
+        0.8256475047378395,
+        0.187683284457478,
+        0.1120162932790224,
+        0.3425101214574899,
+        0.8398309065288868,
+        0.49366391184573005,
+        0.0225787284610814,
+        0.3029465930018416
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14644,
+          121,
+          51,
+          8,
+          27,
+          39,
+          1,
+          504,
+          0,
+          5,
+          228,
+          73,
+          3,
+          744,
+          14,
+          307,
+          4,
+          7,
+          0
+        ],
+        [
+          0,
+          97,
+          11848,
+          92,
+          8,
+          20,
+          35,
+          3,
+          0,
+          18,
+          12,
+          186,
+          35,
+          1,
+          97,
+          0,
+          16,
+          2,
+          7,
+          0
+        ],
+        [
+          0,
+          140,
+          138,
+          12497,
+          13,
+          11,
+          2,
+          168,
+          0,
+          33,
+          0,
+          0,
+          6,
+          1,
+          138,
+          118,
+          30,
+          4,
+          569,
+          0
+        ],
+        [
+          0,
+          29,
+          620,
+          33,
+          1149,
+          55,
+          0,
+          0,
+          0,
+          0,
+          95,
+          0,
+          11,
+          7,
+          0,
+          0,
+          4,
+          43,
+          1,
+          0
+        ],
+        [
+          0,
+          71,
+          4,
+          26,
+          0,
+          5563,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          11,
+          0,
+          95,
+          0,
+          0
+        ],
+        [
+          0,
+          72,
+          116,
+          5,
+          10,
+          0,
+          1284,
+          44,
+          187,
+          0,
+          2,
+          399,
+          0,
+          0,
+          72,
+          0,
+          5,
+          212,
+          0,
+          0
+        ],
+        [
+          0,
+          6,
+          0,
+          15,
+          0,
+          0,
+          6,
+          4145,
+          364,
+          107,
+          0,
+          18,
+          622,
+          0,
+          70,
+          6,
+          14,
+          0,
+          6,
+          0
+        ],
+        [
+          0,
+          25,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1,
+          6562,
+          0,
+          0,
+          8,
+          0,
+          0,
+          0,
+          0,
+          2,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          1,
+          20,
+          3,
+          0,
+          1,
+          0,
+          20,
+          0,
+          2067,
+          0,
+          0,
+          35,
+          15,
+          2,
+          2,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          33,
+          930,
+          0,
+          17,
+          1,
+          0,
+          0,
+          0,
+          4,
+          177,
+          0,
+          0,
+          0,
+          4,
+          0,
+          31,
+          5,
+          0,
+          0
+        ],
+        [
+          0,
+          8,
+          0,
+          0,
+          90,
+          0,
+          9,
+          3,
+          7,
+          0,
+          0,
+          6535,
+          0,
+          0,
+          15,
+          0,
+          70,
+          0,
+          5,
+          0
+        ],
+        [
+          0,
+          112,
+          17,
+          210,
+          0,
+          4,
+          4,
+          411,
+          490,
+          2917,
+          3,
+          159,
+          1344,
+          159,
+          129,
+          18,
+          12,
+          6,
+          51,
+          0
+        ],
+        [
+          0,
+          1,
+          47,
+          63,
+          0,
+          0,
+          0,
+          216,
+          9,
+          27,
+          0,
+          76,
+          226,
+          110,
+          8,
+          4,
+          8,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          1002,
+          17,
+          41,
+          0,
+          2,
+          1,
+          45,
+          424,
+          0,
+          1,
+          70,
+          0,
+          0,
+          1692,
+          0,
+          193,
+          16,
+          0,
+          0
+        ],
+        [
+          0,
+          27,
+          6,
+          36,
+          4,
+          6,
+          0,
+          0,
+          0,
+          42,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1788,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          53,
+          0,
+          6,
+          0,
+          0,
+          0,
+          28,
+          888,
+          0,
+          0,
+          14,
+          0,
+          0,
+          48,
+          0,
+          1792,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          212,
+          396,
+          83,
+          18,
+          344,
+          0,
+          0,
+          0,
+          47,
+          136,
+          0,
+          0,
+          0,
+          0,
+          1,
+          20,
+          38,
+          0,
+          0
+        ],
+        [
+          0,
+          10,
+          0,
+          353,
+          0,
+          0,
+          0,
+          157,
+          1,
+          0,
+          0,
+          15,
+          107,
+          0,
+          90,
+          46,
+          89,
+          0,
+          658,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "add:0.5": {
+      "miou": 0.49560936060529176,
+      "oa": 0.7815897430404559,
+      "macro_f1": 0.6142095713562745,
+      "kappa": 0.7570831504320071,
+      "per_class_iou": [
+        0.7809832522960561,
+        0.7747635312664214,
+        0.838018830393847,
+        0.4392241379310345,
+        0.8724077885072028,
+        0.413290113452188,
+        0.6302926525529265,
+        0.7018746652383503,
+        0.3770852428964253,
+        0.01990049751243781,
+        0.7929901423877328,
+        0.1576155242216948,
+        0.16926770708283315,
+        0.3483215913800249,
+        0.7415110356536503,
+        0.44854032657100446,
+        0.07692307692307693,
+        0.3379583746283449
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14456,
+          122,
+          84,
+          5,
+          27,
+          18,
+          1,
+          566,
+          0,
+          4,
+          272,
+          61,
+          3,
+          759,
+          6,
+          373,
+          7,
+          16,
+          0
+        ],
+        [
+          0,
+          115,
+          11795,
+          102,
+          18,
+          28,
+          17,
+          1,
+          1,
+          20,
+          21,
+          196,
+          35,
+          1,
+          73,
+          0,
+          38,
+          13,
+          3,
+          0
+        ],
+        [
+          0,
+          122,
+          156,
+          12639,
+          5,
+          11,
+          1,
+          231,
+          0,
+          38,
+          5,
+          0,
+          23,
+          2,
+          139,
+          109,
+          28,
+          9,
+          350,
+          0
+        ],
+        [
+          0,
+          32,
+          840,
+          22,
+          1019,
+          58,
+          0,
+          0,
+          0,
+          0,
+          11,
+          0,
+          18,
+          0,
+          0,
+          2,
+          0,
+          45,
+          0,
+          0
+        ],
+        [
+          0,
+          54,
+          5,
+          31,
+          41,
+          5511,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          24,
+          0,
+          104,
+          0,
+          0
+        ],
+        [
+          0,
+          83,
+          220,
+          17,
+          6,
+          0,
+          1020,
+          33,
+          113,
+          0,
+          6,
+          600,
+          0,
+          0,
+          53,
+          0,
+          6,
+          251,
+          0,
+          0
+        ],
+        [
+          0,
+          6,
+          0,
+          32,
+          0,
+          0,
+          5,
+          4049,
+          375,
+          27,
+          0,
+          30,
+          594,
+          0,
+          35,
+          96,
+          125,
+          0,
+          5,
+          0
+        ],
+        [
+          0,
+          29,
+          0,
+          0,
+          0,
+          0,
+          0,
+          2,
+          6552,
+          0,
+          0,
+          9,
+          0,
+          0,
+          5,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          0,
+          14,
+          2,
+          0,
+          0,
+          0,
+          20,
+          5,
+          2057,
+          3,
+          0,
+          41,
+          4,
+          3,
+          16,
+          0,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          47,
+          1045,
+          2,
+          20,
+          7,
+          0,
+          0,
+          0,
+          4,
+          28,
+          0,
+          0,
+          0,
+          1,
+          1,
+          24,
+          23,
+          0,
+          0
+        ],
+        [
+          0,
+          3,
+          0,
+          0,
+          106,
+          0,
+          0,
+          4,
+          8,
+          0,
+          0,
+          6516,
+          2,
+          0,
+          27,
+          0,
+          72,
+          0,
+          4,
+          0
+        ],
+        [
+          0,
+          102,
+          17,
+          287,
+          0,
+          1,
+          19,
+          386,
+          374,
+          3084,
+          12,
+          173,
+          1129,
+          27,
+          74,
+          152,
+          110,
+          1,
+          98,
+          0
+        ],
+        [
+          0,
+          0,
+          42,
+          83,
+          0,
+          0,
+          0,
+          198,
+          15,
+          23,
+          4,
+          30,
+          220,
+          141,
+          14,
+          8,
+          17,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          931,
+          12,
+          42,
+          0,
+          0,
+          0,
+          38,
+          446,
+          0,
+          7,
+          97,
+          0,
+          0,
+          1681,
+          0,
+          250,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          29,
+          4,
+          58,
+          0,
+          7,
+          0,
+          0,
+          0,
+          44,
+          0,
+          0,
+          0,
+          0,
+          1,
+          1747,
+          0,
+          5,
+          14,
+          0
+        ],
+        [
+          0,
+          41,
+          0,
+          13,
+          0,
+          0,
+          0,
+          12,
+          824,
+          0,
+          2,
+          40,
+          0,
+          0,
+          82,
+          0,
+          1813,
+          0,
+          2,
+          0
+        ],
+        [
+          0,
+          123,
+          270,
+          120,
+          72,
+          389,
+          0,
+          0,
+          0,
+          49,
+          130,
+          0,
+          0,
+          0,
+          0,
+          0,
+          7,
+          135,
+          0,
+          0
+        ],
+        [
+          0,
+          13,
+          0,
+          319,
+          0,
+          0,
+          0,
+          119,
+          10,
+          0,
+          0,
+          28,
+          123,
+          0,
+          37,
+          33,
+          162,
+          0,
+          682,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    }
+  },
+  "seconds": 11.983984745107591,
+  "test_used_for_selection": false,
+  "model_count": 1
+}

main_method/configurations/32X32_highest_observed_test_seed3407/test_results.json

@@ -0,0 +1,1883 @@
+{
+  "kind": "attention",
+  "seed": 3407,
+  "mode": "add",
+  "alpha": 0.1,
+  "metrics": {
+    "miou": 0.4952977260959119,
+    "oa": 0.809438708403747,
+    "macro_f1": 0.6244851115289156,
+    "kappa": 0.7633505948395706,
+    "per_class_iou": [
+      0.8084389779816274,
+      0.7150961184355896,
+      0.8763378415995546,
+      0.4874198708984528,
+      0.8740049868785484,
+      0.37208006385830683,
+      0.4537028497648252,
+      0.6245882473592452,
+      0.8043280486177659,
+      0.08840140567289417,
+      0.5444820072275975,
+      0.3127379815711673,
+      0.400269398461593,
+      0.275189878983062,
+      0.6285072951739619,
+      0.28143899488860274,
+      0.1002876053896462,
+      0.26804749696397245
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1300978,
+        7108,
+        8230,
+        1043,
+        780,
+        944,
+        2440,
+        19265,
+        725,
+        551,
+        3746,
+        9121,
+        500,
+        30359,
+        1046,
+        77382,
+        846,
+        939,
+        0
+      ],
+      [
+        0,
+        10132,
+        485443,
+        4883,
+        3909,
+        1030,
+        1783,
+        190,
+        754,
+        550,
+        29667,
+        17322,
+        558,
+        315,
+        1146,
+        236,
+        854,
+        1856,
+        52,
+        0
+      ],
+      [
+        0,
+        15669,
+        3059,
+        639072,
+        408,
+        1060,
+        215,
+        4858,
+        875,
+        3567,
+        183,
+        23,
+        2780,
+        352,
+        3898,
+        4578,
+        822,
+        136,
+        6734,
+        0
+      ],
+      [
+        0,
+        7422,
+        42127,
+        1657,
+        87138,
+        1460,
+        4693,
+        59,
+        217,
+        70,
+        10104,
+        4144,
+        319,
+        384,
+        663,
+        63,
+        334,
+        2531,
+        7,
+        0
+      ],
+      [
+        0,
+        2110,
+        1205,
+        853,
+        338,
+        120229,
+        305,
+        121,
+        22,
+        231,
+        741,
+        257,
+        29,
+        33,
+        1797,
+        27,
+        139,
+        682,
+        0,
+        0
+      ],
+      [
+        0,
+        3690,
+        7059,
+        651,
+        3536,
+        317,
+        24705,
+        170,
+        843,
+        99,
+        2928,
+        5956,
+        173,
+        399,
+        2204,
+        327,
+        151,
+        554,
+        0,
+        0
+      ],
+      [
+        0,
+        1302,
+        139,
+        2981,
+        24,
+        240,
+        34,
+        49195,
+        7301,
+        2498,
+        91,
+        370,
+        1548,
+        1487,
+        3005,
+        9797,
+        651,
+        184,
+        1086,
+        0
+      ],
+      [
+        0,
+        17381,
+        135,
+        4096,
+        0,
+        0,
+        22,
+        1196,
+        152259,
+        2,
+        1,
+        322,
+        1285,
+        52,
+        479,
+        409,
+        9586,
+        2,
+        250,
+        0
+      ],
+      [
+        0,
+        253,
+        197,
+        1039,
+        34,
+        103,
+        306,
+        729,
+        44,
+        66308,
+        0,
+        36,
+        877,
+        40,
+        614,
+        363,
+        64,
+        0,
+        40,
+        0
+      ],
+      [
+        0,
+        2578,
+        42312,
+        430,
+        1677,
+        110,
+        163,
+        5,
+        8,
+        4,
+        9861,
+        107,
+        11,
+        0,
+        312,
+        8,
+        125,
+        651,
+        0,
+        0
+      ],
+      [
+        0,
+        1154,
+        2400,
+        13,
+        3,
+        0,
+        1616,
+        209,
+        1202,
+        0,
+        173,
+        60719,
+        79,
+        0,
+        1496,
+        0,
+        730,
+        2,
+        164,
+        0
+      ],
+      [
+        0,
+        2954,
+        121,
+        4164,
+        2,
+        13,
+        547,
+        9854,
+        3853,
+        1906,
+        63,
+        4578,
+        27186,
+        871,
+        1364,
+        390,
+        2162,
+        89,
+        598,
+        0
+      ],
+      [
+        0,
+        468,
+        124,
+        1305,
+        3,
+        25,
+        92,
+        3563,
+        508,
+        816,
+        17,
+        290,
+        2859,
+        11292,
+        367,
+        364,
+        479,
+        2,
+        39,
+        0
+      ],
+      [
+        0,
+        52773,
+        1184,
+        878,
+        607,
+        373,
+        1429,
+        866,
+        7094,
+        569,
+        800,
+        1108,
+        1051,
+        321,
+        50073,
+        291,
+        7693,
+        424,
+        260,
+        0
+      ],
+      [
+        0,
+        1398,
+        168,
+        5730,
+        133,
+        139,
+        10,
+        767,
+        26,
+        180,
+        15,
+        2122,
+        731,
+        4,
+        369,
+        54320,
+        82,
+        22,
+        2100,
+        0
+      ],
+      [
+        0,
+        11247,
+        351,
+        705,
+        4,
+        0,
+        42,
+        391,
+        10659,
+        49,
+        59,
+        982,
+        1147,
+        56,
+        487,
+        20,
+        50491,
+        7,
+        162,
+        0
+      ],
+      [
+        0,
+        7947,
+        10436,
+        1212,
+        3597,
+        2787,
+        390,
+        44,
+        14,
+        7,
+        7792,
+        2,
+        719,
+        752,
+        1832,
+        62,
+        74,
+        5091,
+        11,
+        0
+      ],
+      [
+        0,
+        4766,
+        45,
+        2137,
+        64,
+        5,
+        44,
+        1035,
+        3613,
+        119,
+        1,
+        192,
+        2927,
+        32,
+        3772,
+        130,
+        1216,
+        7,
+        11919,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "reference": {
+    "miou": 0.4923823641221446,
+    "oa": 0.8069722305391867,
+    "macro_f1": 0.6220716182656123,
+    "kappa": 0.7604756314593856,
+    "per_class_iou": [
+      0.8075790627351255,
+      0.71292826214508,
+      0.8722037487999142,
+      0.49159387306580987,
+      0.8753945402194118,
+      0.3695274547328132,
+      0.44380969707996,
+      0.618820955172456,
+      0.7991021866100304,
+      0.09855478879306705,
+      0.5415849299975815,
+      0.3029233700492677,
+      0.38863181158919813,
+      0.2724438255931417,
+      0.623407163708818,
+      0.2832768116184144,
+      0.09794562774695224,
+      0.26315444454156106
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1299809,
+        7054,
+        7868,
+        1175,
+        742,
+        1048,
+        2568,
+        20005,
+        768,
+        615,
+        3295,
+        9943,
+        588,
+        30648,
+        989,
+        77038,
+        790,
+        1060,
+        0
+      ],
+      [
+        0,
+        9859,
+        479954,
+        4841,
+        4319,
+        1012,
+        2059,
+        205,
+        754,
+        550,
+        33703,
+        18399,
+        572,
+        489,
+        1251,
+        226,
+        886,
+        1549,
+        52,
+        0
+      ],
+      [
+        0,
+        16269,
+        3221,
+        635028,
+        530,
+        1075,
+        235,
+        5684,
+        971,
+        3614,
+        217,
+        25,
+        3166,
+        458,
+        4014,
+        4873,
+        892,
+        137,
+        7880,
+        0
+      ],
+      [
+        0,
+        7275,
+        39630,
+        1499,
+        88130,
+        1366,
+        5100,
+        62,
+        247,
+        69,
+        11784,
+        3859,
+        335,
+        391,
+        687,
+        59,
+        385,
+        2507,
+        7,
+        0
+      ],
+      [
+        0,
+        2038,
+        1202,
+        849,
+        339,
+        120091,
+        328,
+        119,
+        27,
+        241,
+        828,
+        257,
+        32,
+        36,
+        1857,
+        27,
+        150,
+        698,
+        0,
+        0
+      ],
+      [
+        0,
+        3661,
+        6519,
+        626,
+        3375,
+        331,
+        25102,
+        184,
+        884,
+        96,
+        3047,
+        5974,
+        179,
+        400,
+        2361,
+        321,
+        142,
+        560,
+        0,
+        0
+      ],
+      [
+        0,
+        1361,
+        139,
+        2822,
+        18,
+        239,
+        48,
+        48788,
+        7325,
+        2676,
+        106,
+        347,
+        1797,
+        1652,
+        3326,
+        9436,
+        691,
+        52,
+        1110,
+        0
+      ],
+      [
+        0,
+        17496,
+        131,
+        4134,
+        0,
+        0,
+        28,
+        1205,
+        151587,
+        5,
+        2,
+        256,
+        1490,
+        77,
+        484,
+        515,
+        9821,
+        3,
+        243,
+        0
+      ],
+      [
+        0,
+        232,
+        197,
+        1044,
+        38,
+        102,
+        354,
+        822,
+        23,
+        66220,
+        0,
+        30,
+        875,
+        53,
+        590,
+        363,
+        59,
+        0,
+        45,
+        0
+      ],
+      [
+        0,
+        2589,
+        40372,
+        432,
+        1697,
+        85,
+        183,
+        6,
+        6,
+        3,
+        11668,
+        128,
+        13,
+        0,
+        328,
+        9,
+        143,
+        700,
+        0,
+        0
+      ],
+      [
+        0,
+        1201,
+        2390,
+        12,
+        4,
+        0,
+        1850,
+        224,
+        1190,
+        0,
+        187,
+        60462,
+        122,
+        0,
+        1454,
+        0,
+        684,
+        0,
+        180,
+        0
+      ],
+      [
+        0,
+        2978,
+        119,
+        4039,
+        5,
+        14,
+        597,
+        9868,
+        3941,
+        1934,
+        59,
+        4827,
+        26869,
+        905,
+        1457,
+        341,
+        2151,
+        74,
+        537,
+        0
+      ],
+      [
+        0,
+        505,
+        118,
+        1280,
+        2,
+        27,
+        105,
+        3700,
+        479,
+        856,
+        19,
+        235,
+        2717,
+        11254,
+        430,
+        362,
+        482,
+        4,
+        38,
+        0
+      ],
+      [
+        0,
+        52630,
+        1153,
+        729,
+        599,
+        370,
+        1654,
+        912,
+        7181,
+        630,
+        800,
+        1006,
+        1038,
+        375,
+        49894,
+        305,
+        7834,
+        405,
+        279,
+        0
+      ],
+      [
+        0,
+        1535,
+        175,
+        5701,
+        139,
+        134,
+        10,
+        958,
+        53,
+        178,
+        19,
+        2044,
+        902,
+        13,
+        434,
+        53815,
+        96,
+        19,
+        2091,
+        0
+      ],
+      [
+        0,
+        10908,
+        344,
+        660,
+        5,
+        0,
+        48,
+        386,
+        10783,
+        50,
+        67,
+        797,
+        1211,
+        65,
+        427,
+        24,
+        50870,
+        10,
+        204,
+        0
+      ],
+      [
+        0,
+        8066,
+        9726,
+        1198,
+        3564,
+        2564,
+        469,
+        60,
+        10,
+        10,
+        8574,
+        2,
+        722,
+        769,
+        1940,
+        73,
+        83,
+        4925,
+        14,
+        0
+      ],
+      [
+        0,
+        4907,
+        45,
+        2050,
+        73,
+        5,
+        52,
+        1034,
+        3605,
+        141,
+        2,
+        198,
+        2870,
+        74,
+        3653,
+        85,
+        1181,
+        6,
+        12043,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "standalone": {
+    "miou": 0.42322742079483355,
+    "oa": 0.7650703817158506,
+    "macro_f1": 0.5514021279229557,
+    "kappa": 0.7100282789129488,
+    "per_class_iou": [
+      0.7766295817357658,
+      0.668194300892582,
+      0.796005824300275,
+      0.2823564887555746,
+      0.7571911845511178,
+      0.26546953392908423,
+      0.4166956858193074,
+      0.6035350147571773,
+      0.755304001976866,
+      0.023774912075029308,
+      0.45084315311297724,
+      0.27075090077145825,
+      0.29968979344783236,
+      0.2566058092518448,
+      0.5429309094012718,
+      0.21723143776375717,
+      0.07717463180042079,
+      0.15771040996466096
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1235992,
+        12389,
+        33426,
+        2583,
+        2160,
+        275,
+        1599,
+        17333,
+        956,
+        1885,
+        12887,
+        4105,
+        417,
+        43908,
+        2119,
+        85000,
+        7051,
+        1918,
+        0
+      ],
+      [
+        0,
+        11703,
+        490039,
+        8270,
+        6171,
+        2880,
+        767,
+        150,
+        708,
+        492,
+        11935,
+        15297,
+        1938,
+        127,
+        941,
+        670,
+        1340,
+        6980,
+        272,
+        0
+      ],
+      [
+        0,
+        14395,
+        4677,
+        615014,
+        1024,
+        1127,
+        94,
+        816,
+        1848,
+        5514,
+        2253,
+        129,
+        3932,
+        457,
+        7485,
+        7276,
+        1504,
+        2676,
+        18068,
+        0
+      ],
+      [
+        0,
+        6977,
+        71945,
+        2187,
+        53373,
+        6666,
+        2013,
+        68,
+        130,
+        35,
+        2940,
+        6946,
+        479,
+        125,
+        1250,
+        195,
+        422,
+        7553,
+        88,
+        0
+      ],
+      [
+        0,
+        3277,
+        2058,
+        1045,
+        1659,
+        114376,
+        240,
+        51,
+        49,
+        574,
+        718,
+        703,
+        87,
+        239,
+        1415,
+        80,
+        89,
+        2444,
+        15,
+        0
+      ],
+      [
+        0,
+        2956,
+        12400,
+        1648,
+        6524,
+        146,
+        15715,
+        184,
+        600,
+        247,
+        2439,
+        6104,
+        131,
+        347,
+        1989,
+        214,
+        588,
+        1521,
+        9,
+        0
+      ],
+      [
+        0,
+        1025,
+        1542,
+        5349,
+        79,
+        272,
+        9,
+        43078,
+        6347,
+        1035,
+        540,
+        1260,
+        2591,
+        580,
+        1380,
+        9267,
+        701,
+        5309,
+        1569,
+        0
+      ],
+      [
+        0,
+        13585,
+        199,
+        6713,
+        0,
+        0,
+        15,
+        4346,
+        143960,
+        0,
+        156,
+        2075,
+        2401,
+        20,
+        2296,
+        489,
+        8480,
+        217,
+        2525,
+        0
+      ],
+      [
+        0,
+        694,
+        153,
+        1308,
+        33,
+        257,
+        46,
+        201,
+        174,
+        64188,
+        55,
+        163,
+        779,
+        70,
+        610,
+        1251,
+        235,
+        731,
+        99,
+        0
+      ],
+      [
+        0,
+        2203,
+        46064,
+        1175,
+        1655,
+        1528,
+        186,
+        11,
+        12,
+        25,
+        2028,
+        135,
+        538,
+        7,
+        278,
+        210,
+        210,
+        2029,
+        68,
+        0
+      ],
+      [
+        0,
+        709,
+        3177,
+        36,
+        100,
+        31,
+        527,
+        298,
+        1514,
+        0,
+        24,
+        59647,
+        39,
+        82,
+        1718,
+        13,
+        1906,
+        120,
+        19,
+        0
+      ],
+      [
+        0,
+        2423,
+        314,
+        5259,
+        45,
+        78,
+        435,
+        8028,
+        4097,
+        2152,
+        404,
+        3109,
+        24497,
+        568,
+        1295,
+        1376,
+        3870,
+        465,
+        2300,
+        0
+      ],
+      [
+        0,
+        576,
+        226,
+        1541,
+        107,
+        15,
+        76,
+        1545,
+        450,
+        328,
+        291,
+        1122,
+        5801,
+        7922,
+        295,
+        584,
+        446,
+        1084,
+        204,
+        0
+      ],
+      [
+        0,
+        45485,
+        1688,
+        2631,
+        1096,
+        751,
+        383,
+        684,
+        6176,
+        399,
+        463,
+        3575,
+        2192,
+        294,
+        51849,
+        784,
+        7291,
+        1569,
+        484,
+        0
+      ],
+      [
+        0,
+        606,
+        201,
+        6777,
+        91,
+        156,
+        2,
+        462,
+        50,
+        1374,
+        292,
+        2066,
+        753,
+        64,
+        829,
+        50890,
+        114,
+        444,
+        3145,
+        0
+      ],
+      [
+        0,
+        12682,
+        411,
+        2382,
+        23,
+        7,
+        7,
+        1029,
+        8545,
+        93,
+        41,
+        4745,
+        909,
+        84,
+        3917,
+        57,
+        41592,
+        54,
+        281,
+        0
+      ],
+      [
+        0,
+        4342,
+        15162,
+        1896,
+        4161,
+        5797,
+        353,
+        12,
+        86,
+        103,
+        2481,
+        13,
+        626,
+        336,
+        753,
+        100,
+        114,
+        6419,
+        15,
+        0
+      ],
+      [
+        0,
+        1841,
+        92,
+        2693,
+        284,
+        63,
+        7,
+        1963,
+        2932,
+        609,
+        21,
+        2012,
+        2462,
+        4,
+        3904,
+        731,
+        2295,
+        159,
+        9952,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "records": {
+    "add:0.1": {
+      "miou": 0.4952977260959119,
+      "oa": 0.809438708403747,
+      "macro_f1": 0.6244851115289156,
+      "kappa": 0.7633505948395706,
+      "per_class_iou": [
+        0.8084389779816274,
+        0.7150961184355896,
+        0.8763378415995546,
+        0.4874198708984528,
+        0.8740049868785484,
+        0.37208006385830683,
+        0.4537028497648252,
+        0.6245882473592452,
+        0.8043280486177659,
+        0.08840140567289417,
+        0.5444820072275975,
+        0.3127379815711673,
+        0.400269398461593,
+        0.275189878983062,
+        0.6285072951739619,
+        0.28143899488860274,
+        0.1002876053896462,
+        0.26804749696397245
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          1300978,
+          7108,
+          8230,
+          1043,
+          780,
+          944,
+          2440,
+          19265,
+          725,
+          551,
+          3746,
+          9121,
+          500,
+          30359,
+          1046,
+          77382,
+          846,
+          939,
+          0
+        ],
+        [
+          0,
+          10132,
+          485443,
+          4883,
+          3909,
+          1030,
+          1783,
+          190,
+          754,
+          550,
+          29667,
+          17322,
+          558,
+          315,
+          1146,
+          236,
+          854,
+          1856,
+          52,
+          0
+        ],
+        [
+          0,
+          15669,
+          3059,
+          639072,
+          408,
+          1060,
+          215,
+          4858,
+          875,
+          3567,
+          183,
+          23,
+          2780,
+          352,
+          3898,
+          4578,
+          822,
+          136,
+          6734,
+          0
+        ],
+        [
+          0,
+          7422,
+          42127,
+          1657,
+          87138,
+          1460,
+          4693,
+          59,
+          217,
+          70,
+          10104,
+          4144,
+          319,
+          384,
+          663,
+          63,
+          334,
+          2531,
+          7,
+          0
+        ],
+        [
+          0,
+          2110,
+          1205,
+          853,
+          338,
+          120229,
+          305,
+          121,
+          22,
+          231,
+          741,
+          257,
+          29,
+          33,
+          1797,
+          27,
+          139,
+          682,
+          0,
+          0
+        ],
+        [
+          0,
+          3690,
+          7059,
+          651,
+          3536,
+          317,
+          24705,
+          170,
+          843,
+          99,
+          2928,
+          5956,
+          173,
+          399,
+          2204,
+          327,
+          151,
+          554,
+          0,
+          0
+        ],
+        [
+          0,
+          1302,
+          139,
+          2981,
+          24,
+          240,
+          34,
+          49195,
+          7301,
+          2498,
+          91,
+          370,
+          1548,
+          1487,
+          3005,
+          9797,
+          651,
+          184,
+          1086,
+          0
+        ],
+        [
+          0,
+          17381,
+          135,
+          4096,
+          0,
+          0,
+          22,
+          1196,
+          152259,
+          2,
+          1,
+          322,
+          1285,
+          52,
+          479,
+          409,
+          9586,
+          2,
+          250,
+          0
+        ],
+        [
+          0,
+          253,
+          197,
+          1039,
+          34,
+          103,
+          306,
+          729,
+          44,
+          66308,
+          0,
+          36,
+          877,
+          40,
+          614,
+          363,
+          64,
+          0,
+          40,
+          0
+        ],
+        [
+          0,
+          2578,
+          42312,
+          430,
+          1677,
+          110,
+          163,
+          5,
+          8,
+          4,
+          9861,
+          107,
+          11,
+          0,
+          312,
+          8,
+          125,
+          651,
+          0,
+          0
+        ],
+        [
+          0,
+          1154,
+          2400,
+          13,
+          3,
+          0,
+          1616,
+          209,
+          1202,
+          0,
+          173,
+          60719,
+          79,
+          0,
+          1496,
+          0,
+          730,
+          2,
+          164,
+          0
+        ],
+        [
+          0,
+          2954,
+          121,
+          4164,
+          2,
+          13,
+          547,
+          9854,
+          3853,
+          1906,
+          63,
+          4578,
+          27186,
+          871,
+          1364,
+          390,
+          2162,
+          89,
+          598,
+          0
+        ],
+        [
+          0,
+          468,
+          124,
+          1305,
+          3,
+          25,
+          92,
+          3563,
+          508,
+          816,
+          17,
+          290,
+          2859,
+          11292,
+          367,
+          364,
+          479,
+          2,
+          39,
+          0
+        ],
+        [
+          0,
+          52773,
+          1184,
+          878,
+          607,
+          373,
+          1429,
+          866,
+          7094,
+          569,
+          800,
+          1108,
+          1051,
+          321,
+          50073,
+          291,
+          7693,
+          424,
+          260,
+          0
+        ],
+        [
+          0,
+          1398,
+          168,
+          5730,
+          133,
+          139,
+          10,
+          767,
+          26,
+          180,
+          15,
+          2122,
+          731,
+          4,
+          369,
+          54320,
+          82,
+          22,
+          2100,
+          0
+        ],
+        [
+          0,
+          11247,
+          351,
+          705,
+          4,
+          0,
+          42,
+          391,
+          10659,
+          49,
+          59,
+          982,
+          1147,
+          56,
+          487,
+          20,
+          50491,
+          7,
+          162,
+          0
+        ],
+        [
+          0,
+          7947,
+          10436,
+          1212,
+          3597,
+          2787,
+          390,
+          44,
+          14,
+          7,
+          7792,
+          2,
+          719,
+          752,
+          1832,
+          62,
+          74,
+          5091,
+          11,
+          0
+        ],
+        [
+          0,
+          4766,
+          45,
+          2137,
+          64,
+          5,
+          44,
+          1035,
+          3613,
+          119,
+          1,
+          192,
+          2927,
+          32,
+          3772,
+          130,
+          1216,
+          7,
+          11919,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    }
+  },
+  "seconds": 487.52680730680004,
+  "test_used_for_selection": false,
+  "model_count": 1
+}

main_method/configurations/32X32_recommended_validation_seed3407/manifest.json

@@ -0,0 +1,25 @@
+{
+  "name": "recommended_validation",
+  "seed": 3407,
+  "addition_kind": "cnn_control",
+  "addition_alpha": 0.25,
+  "sam_checkpoint": "sam_network_seed3407.tar",
+  "feature_cluster_checkpoint": "training_feature_cluster_centres_seed3407.tar",
+  "original_cnn_checkpoint": "original_temporal_cnn_seed3407.tar",
+  "addition_checkpoint": "new_temporal_cnn_seed3407.tar",
+  "shared_checkpoint_directory": "../../checkpoints/shared",
+  "selection": "validation_miou",
+  "weights": {
+    "sam": 0.28125,
+    "training_feature_cluster_centres": 0.28125,
+    "original_cnn": 0.1875,
+    "addition": 0.25
+  },
+  "sha256": {
+    "sam_network_seed3407.tar": "aa834986f0756f8bcf5646f3af63d0ccbd59ad46d33f6a64641e98fe14e679f1",
+    "training_feature_cluster_centres_seed3407.tar": "3a17469c8d41370e6808f00c24fc49f8801c88a9e4715b5a19802bba9ec3fb30",
+    "original_temporal_cnn_seed3407.tar": "08ba0ec1c2409596301504f299c40b8eb20346c12241903364d74179b23a1774",
+    "new_temporal_cnn_seed3407.tar": "a08c3485199d8b519bf1a9dad72c84545b7adee818798acdfe068135be3de833",
+    "attention_temporal_cnn_seed3407.tar": "de57690bdbae4ff182b983429e1b6c2683a9ad1fc7bfe9011a7a3cfc24f53bf3"
+  }
+}

main_method/configurations/32X32_recommended_validation_seed3407/selection.json

@@ -0,0 +1,4691 @@
+{
+  "kind": "cnn_control",
+  "seed": 3407,
+  "mode": "add",
+  "alpha": 0.25,
+  "metrics": {
+    "miou": 0.5256398451814701,
+    "oa": 0.7954606313128608,
+    "macro_f1": 0.6400266863319044,
+    "kappa": 0.7725060156424988,
+    "per_class_iou": [
+      0.7863696632193052,
+      0.7940560621411685,
+      0.8422681105804802,
+      0.5216035634743875,
+      0.8953563366655918,
+      0.5666403785488959,
+      0.6681021224238696,
+      0.6854425749817118,
+      0.3865969759193579,
+      0.15913978494623657,
+      0.8521227955584585,
+      0.16817463736895016,
+      0.15324165029469547,
+      0.3526720731960907,
+      0.8232323232323232,
+      0.5073836723321259,
+      0.010297482837528604,
+      0.2888170055452865
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        14827,
+        104,
+        46,
+        8,
+        16,
+        20,
+        1,
+        480,
+        0,
+        3,
+        211,
+        80,
+        3,
+        659,
+        16,
+        296,
+        4,
+        6,
+        0
+      ],
+      [
+        0,
+        160,
+        11756,
+        93,
+        27,
+        17,
+        59,
+        3,
+        0,
+        18,
+        25,
+        184,
+        13,
+        1,
+        99,
+        0,
+        10,
+        4,
+        8,
+        0
+      ],
+      [
+        0,
+        165,
+        132,
+        12522,
+        19,
+        10,
+        2,
+        144,
+        0,
+        31,
+        1,
+        0,
+        2,
+        6,
+        113,
+        137,
+        34,
+        11,
+        539,
+        0
+      ],
+      [
+        0,
+        23,
+        477,
+        28,
+        1171,
+        50,
+        1,
+        0,
+        0,
+        0,
+        130,
+        0,
+        18,
+        10,
+        0,
+        2,
+        6,
+        128,
+        3,
+        0
+      ],
+      [
+        0,
+        83,
+        1,
+        23,
+        0,
+        5553,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        19,
+        8,
+        1,
+        101,
+        0,
+        0
+      ],
+      [
+        0,
+        96,
+        76,
+        5,
+        7,
+        0,
+        1437,
+        49,
+        253,
+        0,
+        0,
+        217,
+        0,
+        0,
+        77,
+        0,
+        5,
+        186,
+        0,
+        0
+      ],
+      [
+        0,
+        7,
+        0,
+        14,
+        0,
+        0,
+        10,
+        4344,
+        415,
+        65,
+        0,
+        10,
+        472,
+        0,
+        33,
+        1,
+        4,
+        0,
+        4,
+        0
+      ],
+      [
+        0,
+        29,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        6559,
+        0,
+        0,
+        9,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        6,
+        20,
+        6,
+        0,
+        1,
+        0,
+        26,
+        0,
+        2071,
+        0,
+        0,
+        16,
+        14,
+        5,
+        1,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        34,
+        886,
+        0,
+        14,
+        0,
+        2,
+        0,
+        0,
+        5,
+        222,
+        0,
+        0,
+        0,
+        5,
+        0,
+        30,
+        4,
+        0,
+        0
+      ],
+      [
+        0,
+        17,
+        0,
+        0,
+        91,
+        0,
+        14,
+        5,
+        10,
+        0,
+        0,
+        6523,
+        0,
+        0,
+        13,
+        0,
+        63,
+        0,
+        6,
+        0
+      ],
+      [
+        0,
+        107,
+        18,
+        205,
+        0,
+        3,
+        10,
+        473,
+        524,
+        2954,
+        6,
+        129,
+        1171,
+        188,
+        120,
+        47,
+        11,
+        8,
+        72,
+        0
+      ],
+      [
+        0,
+        1,
+        44,
+        53,
+        0,
+        0,
+        0,
+        189,
+        8,
+        36,
+        1,
+        71,
+        216,
+        156,
+        12,
+        2,
+        7,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1027,
+        18,
+        38,
+        0,
+        0,
+        10,
+        43,
+        402,
+        0,
+        0,
+        58,
+        0,
+        0,
+        1696,
+        0,
+        205,
+        7,
+        0,
+        0
+      ],
+      [
+        0,
+        28,
+        6,
+        32,
+        4,
+        6,
+        0,
+        0,
+        0,
+        40,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1793,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        51,
+        0,
+        8,
+        0,
+        0,
+        0,
+        19,
+        875,
+        0,
+        0,
+        14,
+        0,
+        0,
+        41,
+        0,
+        1821,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        230,
+        546,
+        75,
+        28,
+        310,
+        0,
+        0,
+        0,
+        42,
+        27,
+        0,
+        0,
+        0,
+        0,
+        4,
+        15,
+        18,
+        0,
+        0
+      ],
+      [
+        0,
+        11,
+        0,
+        373,
+        0,
+        0,
+        0,
+        171,
+        4,
+        0,
+        0,
+        10,
+        100,
+        0,
+        109,
+        51,
+        72,
+        0,
+        625,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "reference": {
+    "miou": 0.517690746616618,
+    "oa": 0.7853386317627274,
+    "macro_f1": 0.6313043933615895,
+    "kappa": 0.7617504573466095,
+    "per_class_iou": [
+      0.7832551694734599,
+      0.810901842177619,
+      0.7879978325657003,
+      0.5577777777777778,
+      0.8986279257465698,
+      0.580084909301428,
+      0.6166109930154874,
+      0.6909798968529628,
+      0.38513513513513514,
+      0.1546572934973638,
+      0.8519243313763861,
+      0.19663702056698165,
+      0.10965323336457357,
+      0.3287156144864437,
+      0.830249768732655,
+      0.5048543689320388,
+      0.02144607843137255,
+      0.20892424766516776
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        14697,
+        126,
+        50,
+        60,
+        18,
+        47,
+        5,
+        490,
+        0,
+        3,
+        219,
+        87,
+        3,
+        699,
+        21,
+        245,
+        5,
+        5,
+        0
+      ],
+      [
+        0,
+        100,
+        11797,
+        79,
+        11,
+        15,
+        56,
+        3,
+        0,
+        19,
+        59,
+        191,
+        21,
+        8,
+        98,
+        0,
+        7,
+        5,
+        8,
+        0
+      ],
+      [
+        0,
+        165,
+        120,
+        11634,
+        26,
+        11,
+        3,
+        200,
+        1,
+        33,
+        3,
+        0,
+        2,
+        6,
+        215,
+        134,
+        39,
+        1,
+        1275,
+        0
+      ],
+      [
+        0,
+        25,
+        305,
+        30,
+        1255,
+        41,
+        21,
+        0,
+        0,
+        0,
+        300,
+        0,
+        12,
+        9,
+        0,
+        0,
+        22,
+        23,
+        4,
+        0
+      ],
+      [
+        0,
+        71,
+        7,
+        25,
+        0,
+        5567,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        18,
+        9,
+        0,
+        92,
+        0,
+        0
+      ],
+      [
+        0,
+        63,
+        73,
+        4,
+        17,
+        4,
+        1503,
+        26,
+        228,
+        0,
+        2,
+        224,
+        0,
+        0,
+        81,
+        0,
+        4,
+        179,
+        0,
+        0
+      ],
+      [
+        0,
+        4,
+        1,
+        7,
+        0,
+        0,
+        15,
+        4061,
+        338,
+        113,
+        0,
+        10,
+        713,
+        2,
+        82,
+        5,
+        3,
+        0,
+        25,
+        0
+      ],
+      [
+        0,
+        21,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        6565,
+        0,
+        0,
+        11,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        5,
+        21,
+        3,
+        0,
+        1,
+        0,
+        23,
+        0,
+        2052,
+        0,
+        0,
+        24,
+        33,
+        4,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        22,
+        868,
+        0,
+        2,
+        0,
+        1,
+        0,
+        0,
+        5,
+        264,
+        0,
+        0,
+        0,
+        5,
+        0,
+        33,
+        2,
+        0,
+        0
+      ],
+      [
+        0,
+        8,
+        1,
+        0,
+        67,
+        0,
+        26,
+        4,
+        11,
+        0,
+        0,
+        6530,
+        0,
+        0,
+        20,
+        0,
+        67,
+        0,
+        8,
+        0
+      ],
+      [
+        0,
+        114,
+        20,
+        133,
+        1,
+        5,
+        3,
+        450,
+        474,
+        2875,
+        0,
+        101,
+        1415,
+        210,
+        164,
+        25,
+        10,
+        10,
+        36,
+        0
+      ],
+      [
+        0,
+        1,
+        46,
+        49,
+        0,
+        3,
+        0,
+        195,
+        5,
+        39,
+        1,
+        98,
+        212,
+        117,
+        17,
+        4,
+        7,
+        0,
+        2,
+        0
+      ],
+      [
+        0,
+        1033,
+        18,
+        37,
+        0,
+        3,
+        10,
+        54,
+        438,
+        0,
+        0,
+        60,
+        5,
+        0,
+        1661,
+        0,
+        165,
+        20,
+        0,
+        0
+      ],
+      [
+        0,
+        25,
+        10,
+        23,
+        10,
+        7,
+        0,
+        2,
+        0,
+        36,
+        0,
+        0,
+        0,
+        0,
+        0,
+        1795,
+        1,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        56,
+        0,
+        5,
+        0,
+        0,
+        0,
+        48,
+        918,
+        0,
+        0,
+        5,
+        0,
+        0,
+        29,
+        0,
+        1768,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        254,
+        455,
+        30,
+        9,
+        298,
+        0,
+        0,
+        0,
+        42,
+        137,
+        0,
+        0,
+        0,
+        0,
+        4,
+        29,
+        35,
+        2,
+        0
+      ],
+      [
+        0,
+        17,
+        0,
+        421,
+        0,
+        0,
+        1,
+        197,
+        0,
+        0,
+        0,
+        4,
+        74,
+        0,
+        117,
+        51,
+        40,
+        0,
+        604,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "standalone": {
+    "miou": 0.4613928392731144,
+    "oa": 0.7604674328681141,
+    "macro_f1": 0.5759941645308279,
+    "kappa": 0.7334592941868356,
+    "per_class_iou": [
+      0.7620059058177485,
+      0.7649862388400349,
+      0.8101845791333945,
+      0.2290852228303362,
+      0.8758389261744967,
+      0.39676840215439857,
+      0.6524031942142534,
+      0.6626579698328577,
+      0.3693058568329718,
+      0.0,
+      0.7717776420281002,
+      0.055872634424752175,
+      0.2665094339622642,
+      0.3076137987344356,
+      0.6036308623298033,
+      0.4603658536585366,
+      0.009932043910088865,
+      0.30613254203758655
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        14709,
+        61,
+        84,
+        15,
+        14,
+        16,
+        2,
+        587,
+        0,
+        1,
+        203,
+        68,
+        3,
+        639,
+        7,
+        357,
+        5,
+        9,
+        0
+      ],
+      [
+        0,
+        384,
+        11396,
+        97,
+        96,
+        26,
+        89,
+        0,
+        3,
+        16,
+        75,
+        187,
+        4,
+        1,
+        29,
+        0,
+        47,
+        23,
+        4,
+        0
+      ],
+      [
+        0,
+        243,
+        159,
+        12378,
+        23,
+        5,
+        1,
+        190,
+        14,
+        43,
+        16,
+        0,
+        42,
+        13,
+        90,
+        289,
+        37,
+        59,
+        266,
+        0
+      ],
+      [
+        0,
+        62,
+        686,
+        2,
+        586,
+        82,
+        21,
+        0,
+        0,
+        0,
+        184,
+        1,
+        25,
+        7,
+        60,
+        12,
+        0,
+        319,
+        0,
+        0
+      ],
+      [
+        0,
+        105,
+        17,
+        19,
+        14,
+        5481,
+        0,
+        0,
+        0,
+        0,
+        3,
+        0,
+        0,
+        0,
+        16,
+        0,
+        0,
+        134,
+        0,
+        0
+      ],
+      [
+        0,
+        147,
+        21,
+        26,
+        5,
+        0,
+        1105,
+        36,
+        224,
+        0,
+        11,
+        738,
+        0,
+        0,
+        78,
+        0,
+        8,
+        9,
+        0,
+        0
+      ],
+      [
+        0,
+        20,
+        0,
+        47,
+        0,
+        0,
+        17,
+        4330,
+        760,
+        0,
+        0,
+        9,
+        147,
+        0,
+        25,
+        0,
+        24,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        55,
+        0,
+        0,
+        0,
+        0,
+        0,
+        5,
+        6502,
+        0,
+        0,
+        6,
+        0,
+        0,
+        29,
+        0,
+        1,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        17,
+        2,
+        16,
+        3,
+        4,
+        0,
+        20,
+        7,
+        2043,
+        2,
+        0,
+        1,
+        3,
+        7,
+        35,
+        0,
+        6,
+        0,
+        0
+      ],
+      [
+        0,
+        147,
+        836,
+        16,
+        115,
+        2,
+        28,
+        0,
+        0,
+        2,
+        0,
+        0,
+        0,
+        0,
+        21,
+        12,
+        0,
+        23,
+        0,
+        0
+      ],
+      [
+        0,
+        39,
+        0,
+        0,
+        151,
+        0,
+        86,
+        5,
+        17,
+        1,
+        0,
+        6317,
+        1,
+        1,
+        50,
+        0,
+        74,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        99,
+        20,
+        369,
+        3,
+        0,
+        72,
+        668,
+        374,
+        3162,
+        43,
+        175,
+        372,
+        16,
+        77,
+        314,
+        62,
+        5,
+        215,
+        0
+      ],
+      [
+        0,
+        21,
+        19,
+        66,
+        0,
+        0,
+        13,
+        116,
+        15,
+        25,
+        18,
+        1,
+        173,
+        226,
+        53,
+        29,
+        8,
+        13,
+        0,
+        0
+      ],
+      [
+        0,
+        968,
+        11,
+        33,
+        6,
+        0,
+        32,
+        58,
+        473,
+        0,
+        1,
+        53,
+        0,
+        0,
+        1507,
+        0,
+        357,
+        5,
+        0,
+        0
+      ],
+      [
+        0,
+        85,
+        0,
+        75,
+        0,
+        0,
+        2,
+        0,
+        0,
+        114,
+        0,
+        0,
+        10,
+        8,
+        0,
+        1596,
+        0,
+        17,
+        2,
+        0
+      ],
+      [
+        0,
+        24,
+        0,
+        32,
+        0,
+        0,
+        0,
+        61,
+        709,
+        0,
+        0,
+        45,
+        0,
+        0,
+        146,
+        0,
+        1812,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        57,
+        588,
+        209,
+        80,
+        336,
+        0,
+        0,
+        0,
+        3,
+        3,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        19,
+        0,
+        0
+      ],
+      [
+        0,
+        50,
+        0,
+        319,
+        0,
+        0,
+        0,
+        97,
+        31,
+        0,
+        0,
+        25,
+        141,
+        0,
+        75,
+        37,
+        132,
+        0,
+        619,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "records": {
+    "replace:0.0": {
+      "miou": 0.5069881701623682,
+      "oa": 0.775366587761485,
+      "macro_f1": 0.6219409132377508,
+      "kappa": 0.751105731991019,
+      "per_class_iou": [
+        0.7781331627485474,
+        0.8032224168126094,
+        0.7638945508900666,
+        0.4874521480221182,
+        0.9024627349319507,
+        0.5841441441441442,
+        0.58692089974676,
+        0.6966029723991507,
+        0.3621249761131282,
+        0.14381270903010032,
+        0.8547984770907181,
+        0.20548880393227745,
+        0.09766277128547579,
+        0.3258513931888545,
+        0.8012422360248447,
+        0.5073593073593073,
+        0.02595051297525649,
+        0.19866284622731614
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14597,
+          134,
+          59,
+          97,
+          22,
+          60,
+          13,
+          517,
+          2,
+          3,
+          236,
+          93,
+          1,
+          670,
+          34,
+          230,
+          6,
+          6,
+          0
+        ],
+        [
+          0,
+          103,
+          11466,
+          73,
+          93,
+          22,
+          105,
+          5,
+          0,
+          22,
+          170,
+          265,
+          14,
+          18,
+          94,
+          1,
+          10,
+          7,
+          9,
+          0
+        ],
+        [
+          0,
+          165,
+          104,
+          11243,
+          50,
+          13,
+          4,
+          297,
+          7,
+          28,
+          7,
+          0,
+          2,
+          8,
+          245,
+          129,
+          46,
+          2,
+          1518,
+          0
+        ],
+        [
+          0,
+          45,
+          243,
+          34,
+          1146,
+          15,
+          65,
+          0,
+          1,
+          0,
+          431,
+          0,
+          14,
+          3,
+          0,
+          1,
+          34,
+          11,
+          4,
+          0
+        ],
+        [
+          0,
+          65,
+          2,
+          24,
+          0,
+          5570,
+          0,
+          0,
+          2,
+          0,
+          3,
+          0,
+          0,
+          0,
+          17,
+          8,
+          0,
+          98,
+          0,
+          0
+        ],
+        [
+          0,
+          39,
+          61,
+          4,
+          21,
+          4,
+          1621,
+          26,
+          240,
+          0,
+          5,
+          102,
+          2,
+          0,
+          86,
+          0,
+          3,
+          194,
+          0,
+          0
+        ],
+        [
+          0,
+          4,
+          1,
+          4,
+          0,
+          0,
+          15,
+          3940,
+          285,
+          100,
+          0,
+          13,
+          845,
+          6,
+          107,
+          13,
+          3,
+          0,
+          43,
+          0
+        ],
+        [
+          0,
+          11,
+          0,
+          0,
+          0,
+          0,
+          5,
+          0,
+          6562,
+          0,
+          0,
+          17,
+          0,
+          0,
+          2,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          3,
+          20,
+          3,
+          0,
+          1,
+          0,
+          15,
+          0,
+          1895,
+          0,
+          0,
+          26,
+          151,
+          51,
+          1,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          18,
+          826,
+          1,
+          0,
+          1,
+          6,
+          0,
+          0,
+          4,
+          301,
+          0,
+          0,
+          0,
+          5,
+          0,
+          35,
+          5,
+          0,
+          0
+        ],
+        [
+          0,
+          9,
+          2,
+          0,
+          13,
+          0,
+          80,
+          10,
+          15,
+          0,
+          0,
+          6511,
+          0,
+          0,
+          27,
+          0,
+          67,
+          0,
+          8,
+          0
+        ],
+        [
+          0,
+          109,
+          19,
+          109,
+          1,
+          8,
+          7,
+          431,
+          459,
+          2819,
+          0,
+          93,
+          1505,
+          215,
+          168,
+          66,
+          10,
+          10,
+          17,
+          0
+        ],
+        [
+          0,
+          4,
+          33,
+          40,
+          0,
+          5,
+          2,
+          198,
+          5,
+          25,
+          0,
+          92,
+          219,
+          117,
+          30,
+          13,
+          7,
+          1,
+          5,
+          0
+        ],
+        [
+          0,
+          1057,
+          17,
+          37,
+          0,
+          9,
+          15,
+          52,
+          382,
+          0,
+          0,
+          53,
+          16,
+          0,
+          1684,
+          22,
+          132,
+          28,
+          0,
+          0
+        ],
+        [
+          0,
+          18,
+          10,
+          24,
+          13,
+          7,
+          0,
+          2,
+          0,
+          28,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1806,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          52,
+          0,
+          5,
+          0,
+          0,
+          0,
+          71,
+          909,
+          0,
+          0,
+          3,
+          0,
+          0,
+          29,
+          0,
+          1758,
+          0,
+          2,
+          0
+        ],
+        [
+          0,
+          262,
+          324,
+          17,
+          16,
+          276,
+          2,
+          2,
+          0,
+          39,
+          272,
+          0,
+          0,
+          0,
+          2,
+          6,
+          31,
+          43,
+          3,
+          0
+        ],
+        [
+          0,
+          15,
+          2,
+          416,
+          0,
+          0,
+          1,
+          212,
+          0,
+          0,
+          0,
+          1,
+          47,
+          0,
+          131,
+          51,
+          26,
+          0,
+          624,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "replace:0.1": {
+      "miou": 0.5113629710124012,
+      "oa": 0.7790404987093111,
+      "macro_f1": 0.6255474200669079,
+      "kappa": 0.7550350100044476,
+      "per_class_iou": [
+        0.7811167945439045,
+        0.8054339517754152,
+        0.7692098832473527,
+        0.5002143163309044,
+        0.902316539769966,
+        0.5940850277264326,
+        0.5970888355342137,
+        0.6943092870742543,
+        0.36634414722064124,
+        0.15201654601861428,
+        0.8627165718820262,
+        0.20307776861775212,
+        0.10042918454935622,
+        0.32927068999410264,
+        0.8150994575045208,
+        0.5095632315158436,
+        0.023593466424682397,
+        0.1986477784932389
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14660,
+          129,
+          53,
+          94,
+          19,
+          56,
+          9,
+          496,
+          2,
+          3,
+          225,
+          92,
+          1,
+          648,
+          30,
+          253,
+          5,
+          5,
+          0
+        ],
+        [
+          0,
+          110,
+          11591,
+          72,
+          65,
+          21,
+          89,
+          5,
+          0,
+          22,
+          137,
+          216,
+          17,
+          12,
+          93,
+          0,
+          11,
+          7,
+          9,
+          0
+        ],
+        [
+          0,
+          169,
+          107,
+          11332,
+          50,
+          12,
+          5,
+          261,
+          6,
+          33,
+          4,
+          0,
+          2,
+          8,
+          216,
+          124,
+          43,
+          3,
+          1493,
+          0
+        ],
+        [
+          0,
+          45,
+          284,
+          34,
+          1167,
+          14,
+          50,
+          0,
+          1,
+          0,
+          387,
+          0,
+          14,
+          3,
+          0,
+          1,
+          32,
+          11,
+          4,
+          0
+        ],
+        [
+          0,
+          66,
+          2,
+          23,
+          0,
+          5570,
+          0,
+          0,
+          1,
+          0,
+          1,
+          0,
+          0,
+          0,
+          18,
+          8,
+          0,
+          100,
+          0,
+          0
+        ],
+        [
+          0,
+          48,
+          60,
+          3,
+          18,
+          3,
+          1607,
+          31,
+          249,
+          0,
+          4,
+          100,
+          0,
+          0,
+          85,
+          0,
+          4,
+          196,
+          0,
+          0
+        ],
+        [
+          0,
+          4,
+          1,
+          4,
+          0,
+          0,
+          15,
+          3979,
+          314,
+          102,
+          0,
+          12,
+          792,
+          3,
+          103,
+          13,
+          4,
+          0,
+          33,
+          0
+        ],
+        [
+          0,
+          12,
+          0,
+          0,
+          0,
+          0,
+          4,
+          0,
+          6564,
+          0,
+          0,
+          17,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          3,
+          19,
+          3,
+          0,
+          1,
+          0,
+          13,
+          0,
+          1931,
+          0,
+          0,
+          25,
+          128,
+          43,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          20,
+          833,
+          1,
+          0,
+          1,
+          5,
+          0,
+          0,
+          4,
+          294,
+          0,
+          0,
+          0,
+          5,
+          0,
+          34,
+          5,
+          0,
+          0
+        ],
+        [
+          0,
+          11,
+          2,
+          0,
+          32,
+          0,
+          55,
+          10,
+          15,
+          0,
+          0,
+          6523,
+          0,
+          0,
+          21,
+          0,
+          65,
+          0,
+          8,
+          0
+        ],
+        [
+          0,
+          109,
+          19,
+          122,
+          1,
+          7,
+          5,
+          436,
+          467,
+          2845,
+          0,
+          98,
+          1478,
+          214,
+          160,
+          44,
+          11,
+          9,
+          21,
+          0
+        ],
+        [
+          0,
+          3,
+          34,
+          41,
+          0,
+          5,
+          2,
+          198,
+          4,
+          24,
+          0,
+          90,
+          223,
+          117,
+          30,
+          12,
+          8,
+          1,
+          4,
+          0
+        ],
+        [
+          0,
+          1051,
+          17,
+          37,
+          0,
+          5,
+          10,
+          53,
+          410,
+          0,
+          0,
+          57,
+          13,
+          0,
+          1675,
+          15,
+          140,
+          21,
+          0,
+          0
+        ],
+        [
+          0,
+          18,
+          10,
+          22,
+          12,
+          7,
+          0,
+          2,
+          0,
+          34,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1803,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          51,
+          0,
+          6,
+          0,
+          0,
+          0,
+          63,
+          893,
+          0,
+          0,
+          3,
+          0,
+          0,
+          28,
+          0,
+          1785,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          253,
+          396,
+          26,
+          14,
+          289,
+          0,
+          2,
+          0,
+          39,
+          196,
+          0,
+          0,
+          0,
+          2,
+          5,
+          31,
+          39,
+          3,
+          0
+        ],
+        [
+          0,
+          15,
+          1,
+          417,
+          0,
+          0,
+          1,
+          202,
+          0,
+          0,
+          0,
+          1,
+          54,
+          0,
+          131,
+          51,
+          36,
+          0,
+          617,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "replace:0.25": {
+      "miou": 0.5182835011064869,
+      "oa": 0.785435031758443,
+      "macro_f1": 0.6316003078697231,
+      "kappa": 0.7618478524534972,
+      "per_class_iou": [
+        0.7832996704581694,
+        0.8062435677530018,
+        0.7874746106973595,
+        0.5129784425868896,
+        0.9010205734650899,
+        0.601304681504221,
+        0.6181900726392252,
+        0.6893835976057965,
+        0.38136389254179975,
+        0.16567342073897498,
+        0.8686102236421726,
+        0.19648829431438128,
+        0.11090742438130156,
+        0.3352238201336844,
+        0.8365921787709497,
+        0.5123804164321891,
+        0.018213866039952998,
+        0.20375426621160408
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14737,
+          116,
+          50,
+          67,
+          18,
+          46,
+          5,
+          478,
+          1,
+          3,
+          212,
+          90,
+          1,
+          639,
+          24,
+          284,
+          5,
+          4,
+          0
+        ],
+        [
+          0,
+          127,
+          11751,
+          77,
+          18,
+          16,
+          74,
+          5,
+          0,
+          20,
+          68,
+          182,
+          16,
+          7,
+          91,
+          0,
+          11,
+          6,
+          8,
+          0
+        ],
+        [
+          0,
+          176,
+          119,
+          11631,
+          32,
+          9,
+          3,
+          211,
+          0,
+          35,
+          0,
+          0,
+          3,
+          7,
+          133,
+          123,
+          43,
+          5,
+          1338,
+          0
+        ],
+        [
+          0,
+          39,
+          369,
+          30,
+          1166,
+          26,
+          12,
+          0,
+          0,
+          0,
+          295,
+          0,
+          18,
+          9,
+          0,
+          1,
+          21,
+          58,
+          3,
+          0
+        ],
+        [
+          0,
+          70,
+          2,
+          24,
+          0,
+          5562,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          7,
+          1,
+          104,
+          0,
+          0
+        ],
+        [
+          0,
+          62,
+          61,
+          3,
+          9,
+          1,
+          1567,
+          42,
+          265,
+          0,
+          4,
+          107,
+          0,
+          0,
+          85,
+          0,
+          5,
+          197,
+          0,
+          0
+        ],
+        [
+          0,
+          5,
+          1,
+          7,
+          0,
+          0,
+          14,
+          4085,
+          376,
+          96,
+          0,
+          10,
+          667,
+          1,
+          91,
+          4,
+          4,
+          0,
+          18,
+          0
+        ],
+        [
+          0,
+          19,
+          0,
+          0,
+          0,
+          0,
+          2,
+          0,
+          6565,
+          0,
+          0,
+          10,
+          0,
+          0,
+          1,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          3,
+          19,
+          3,
+          0,
+          1,
+          0,
+          15,
+          0,
+          2030,
+          0,
+          0,
+          22,
+          62,
+          11,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          25,
+          846,
+          1,
+          2,
+          1,
+          3,
+          0,
+          0,
+          4,
+          278,
+          0,
+          0,
+          0,
+          5,
+          0,
+          32,
+          5,
+          0,
+          0
+        ],
+        [
+          0,
+          14,
+          1,
+          0,
+          65,
+          0,
+          21,
+          9,
+          10,
+          0,
+          0,
+          6525,
+          0,
+          0,
+          20,
+          0,
+          69,
+          0,
+          8,
+          0
+        ],
+        [
+          0,
+          107,
+          18,
+          139,
+          1,
+          5,
+          8,
+          448,
+          476,
+          2894,
+          0,
+          113,
+          1410,
+          208,
+          158,
+          16,
+          9,
+          11,
+          25,
+          0
+        ],
+        [
+          0,
+          1,
+          39,
+          40,
+          1,
+          2,
+          3,
+          209,
+          7,
+          28,
+          1,
+          76,
+          233,
+          121,
+          22,
+          9,
+          4,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          1054,
+          17,
+          36,
+          0,
+          2,
+          11,
+          54,
+          440,
+          0,
+          0,
+          54,
+          10,
+          0,
+          1655,
+          0,
+          155,
+          16,
+          0,
+          0
+        ],
+        [
+          0,
+          25,
+          10,
+          22,
+          10,
+          6,
+          0,
+          2,
+          0,
+          36,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1797,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          49,
+          0,
+          6,
+          0,
+          0,
+          0,
+          46,
+          871,
+          0,
+          0,
+          5,
+          0,
+          0,
+          31,
+          0,
+          1821,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          241,
+          480,
+          43,
+          21,
+          297,
+          0,
+          0,
+          0,
+          43,
+          105,
+          0,
+          0,
+          0,
+          0,
+          5,
+          29,
+          31,
+          0,
+          0
+        ],
+        [
+          0,
+          17,
+          0,
+          421,
+          0,
+          0,
+          1,
+          183,
+          2,
+          0,
+          0,
+          1,
+          71,
+          0,
+          127,
+          50,
+          56,
+          0,
+          597,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "replace:0.5": {
+      "miou": 0.5209658545455325,
+      "oa": 0.7927828536540954,
+      "macro_f1": 0.6373933424943236,
+      "kappa": 0.769462142403631,
+      "per_class_iou": [
+        0.7878516016676341,
+        0.7888686007979983,
+        0.8445144427317204,
+        0.49109856708640903,
+        0.8941347083467612,
+        0.5404040404040404,
+        0.6748503912843333,
+        0.6828175471501511,
+        0.3781158357771261,
+        0.17151607963246554,
+        0.8444444444444444,
+        0.12860438292964244,
+        0.20142421159715157,
+        0.36407237846086765,
+        0.7722902097902098,
+        0.509185632026323,
+        0.008,
+        0.2951923076923077
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14929,
+          93,
+          54,
+          8,
+          14,
+          11,
+          0,
+          480,
+          0,
+          3,
+          217,
+          79,
+          2,
+          547,
+          17,
+          318,
+          3,
+          5,
+          0
+        ],
+        [
+          0,
+          234,
+          11665,
+          95,
+          42,
+          16,
+          74,
+          3,
+          0,
+          18,
+          29,
+          178,
+          6,
+          1,
+          89,
+          0,
+          15,
+          4,
+          8,
+          0
+        ],
+        [
+          0,
+          174,
+          133,
+          12601,
+          14,
+          8,
+          2,
+          155,
+          1,
+          37,
+          8,
+          0,
+          12,
+          1,
+          53,
+          161,
+          35,
+          38,
+          435,
+          0
+        ],
+        [
+          0,
+          31,
+          527,
+          20,
+          1131,
+          48,
+          0,
+          0,
+          0,
+          0,
+          31,
+          0,
+          24,
+          9,
+          0,
+          5,
+          3,
+          218,
+          0,
+          0
+        ],
+        [
+          0,
+          79,
+          1,
+          20,
+          0,
+          5549,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          5,
+          0,
+          116,
+          0,
+          0
+        ],
+        [
+          0,
+          106,
+          51,
+          4,
+          2,
+          0,
+          1391,
+          70,
+          253,
+          0,
+          3,
+          266,
+          0,
+          0,
+          85,
+          0,
+          5,
+          172,
+          0,
+          0
+        ],
+        [
+          0,
+          13,
+          0,
+          14,
+          0,
+          0,
+          14,
+          4398,
+          485,
+          19,
+          0,
+          7,
+          419,
+          0,
+          7,
+          0,
+          3,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          34,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          6553,
+          0,
+          0,
+          8,
+          0,
+          0,
+          2,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          6,
+          17,
+          7,
+          2,
+          3,
+          0,
+          26,
+          0,
+          2063,
+          0,
+          0,
+          12,
+          17,
+          8,
+          5,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          44,
+          862,
+          6,
+          24,
+          0,
+          2,
+          0,
+          0,
+          4,
+          224,
+          0,
+          0,
+          0,
+          3,
+          0,
+          24,
+          9,
+          0,
+          0
+        ],
+        [
+          0,
+          18,
+          0,
+          0,
+          108,
+          0,
+          10,
+          9,
+          11,
+          0,
+          0,
+          6498,
+          0,
+          0,
+          16,
+          0,
+          69,
+          0,
+          3,
+          0
+        ],
+        [
+          0,
+          95,
+          20,
+          219,
+          0,
+          0,
+          34,
+          502,
+          502,
+          3103,
+          18,
+          153,
+          892,
+          157,
+          81,
+          137,
+          18,
+          12,
+          103,
+          0
+        ],
+        [
+          0,
+          8,
+          29,
+          44,
+          0,
+          0,
+          7,
+          170,
+          9,
+          27,
+          7,
+          48,
+          223,
+          198,
+          16,
+          3,
+          6,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          1045,
+          15,
+          37,
+          0,
+          0,
+          12,
+          40,
+          410,
+          0,
+          0,
+          51,
+          0,
+          0,
+          1670,
+          0,
+          223,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          36,
+          4,
+          40,
+          1,
+          5,
+          0,
+          0,
+          0,
+          48,
+          0,
+          0,
+          2,
+          0,
+          0,
+          1767,
+          0,
+          6,
+          0,
+          0
+        ],
+        [
+          0,
+          39,
+          0,
+          16,
+          0,
+          0,
+          0,
+          14,
+          837,
+          0,
+          0,
+          17,
+          0,
+          0,
+          49,
+          0,
+          1857,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          183,
+          558,
+          113,
+          55,
+          323,
+          0,
+          0,
+          0,
+          34,
+          5,
+          0,
+          0,
+          0,
+          0,
+          2,
+          7,
+          15,
+          0,
+          0
+        ],
+        [
+          0,
+          24,
+          0,
+          364,
+          0,
+          0,
+          0,
+          149,
+          11,
+          0,
+          0,
+          8,
+          113,
+          0,
+          108,
+          44,
+          91,
+          0,
+          614,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "add:0.1": {
+      "miou": 0.5212361736883501,
+      "oa": 0.7897301871231028,
+      "macro_f1": 0.634597286240264,
+      "kappa": 0.7664244164888394,
+      "per_class_iou": [
+        0.7848168654173765,
+        0.8042692491304644,
+        0.8103925940941955,
+        0.5514606741573034,
+        0.8984173126614987,
+        0.580632565404139,
+        0.6315869631434663,
+        0.6881551362683438,
+        0.38625725519565624,
+        0.15341264871634314,
+        0.854807063440157,
+        0.19133980036552792,
+        0.11556829035339064,
+        0.3336673346693387,
+        0.8366013071895425,
+        0.5090754395916052,
+        0.019867549668874173,
+        0.23192307692307693
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14742,
+          118,
+          47,
+          30,
+          16,
+          41,
+          5,
+          481,
+          0,
+          3,
+          209,
+          87,
+          3,
+          710,
+          19,
+          260,
+          5,
+          4,
+          0
+        ],
+        [
+          0,
+          113,
+          11793,
+          83,
+          15,
+          16,
+          55,
+          4,
+          0,
+          19,
+          49,
+          186,
+          21,
+          4,
+          99,
+          0,
+          8,
+          4,
+          8,
+          0
+        ],
+        [
+          0,
+          160,
+          129,
+          11993,
+          23,
+          11,
+          3,
+          183,
+          0,
+          33,
+          2,
+          0,
+          2,
+          6,
+          162,
+          130,
+          35,
+          4,
+          992,
+          0
+        ],
+        [
+          0,
+          22,
+          366,
+          31,
+          1227,
+          46,
+          7,
+          0,
+          0,
+          0,
+          250,
+          0,
+          14,
+          9,
+          0,
+          0,
+          20,
+          52,
+          3,
+          0
+        ],
+        [
+          0,
+          73,
+          5,
+          25,
+          0,
+          5563,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          8,
+          2,
+          94,
+          0,
+          0
+        ],
+        [
+          0,
+          75,
+          73,
+          3,
+          14,
+          0,
+          1487,
+          33,
+          240,
+          0,
+          2,
+          217,
+          0,
+          0,
+          82,
+          0,
+          4,
+          178,
+          0,
+          0
+        ],
+        [
+          0,
+          6,
+          1,
+          11,
+          0,
+          0,
+          14,
+          4147,
+          374,
+          107,
+          0,
+          8,
+          619,
+          1,
+          73,
+          1,
+          4,
+          0,
+          13,
+          0
+        ],
+        [
+          0,
+          24,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          6565,
+          0,
+          0,
+          8,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          4,
+          21,
+          3,
+          0,
+          1,
+          0,
+          22,
+          0,
+          2063,
+          0,
+          0,
+          25,
+          23,
+          4,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          31,
+          878,
+          0,
+          4,
+          0,
+          1,
+          0,
+          0,
+          5,
+          245,
+          0,
+          0,
+          0,
+          5,
+          0,
+          30,
+          3,
+          0,
+          0
+        ],
+        [
+          0,
+          9,
+          0,
+          0,
+          74,
+          0,
+          17,
+          5,
+          10,
+          0,
+          0,
+          6535,
+          0,
+          0,
+          18,
+          0,
+          67,
+          0,
+          7,
+          0
+        ],
+        [
+          0,
+          113,
+          18,
+          152,
+          0,
+          4,
+          4,
+          456,
+          497,
+          2891,
+          2,
+          109,
+          1361,
+          205,
+          153,
+          17,
+          8,
+          10,
+          46,
+          0
+        ],
+        [
+          0,
+          1,
+          46,
+          49,
+          0,
+          0,
+          0,
+          200,
+          8,
+          40,
+          1,
+          93,
+          210,
+          121,
+          16,
+          4,
+          6,
+          0,
+          1,
+          0
+        ],
+        [
+          0,
+          1029,
+          18,
+          37,
+          0,
+          2,
+          10,
+          52,
+          437,
+          0,
+          0,
+          60,
+          1,
+          0,
+          1665,
+          0,
+          177,
+          16,
+          0,
+          0
+        ],
+        [
+          0,
+          28,
+          10,
+          27,
+          7,
+          6,
+          0,
+          1,
+          0,
+          38,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1792,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          55,
+          0,
+          6,
+          0,
+          0,
+          0,
+          37,
+          895,
+          0,
+          0,
+          7,
+          0,
+          0,
+          34,
+          0,
+          1795,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          248,
+          503,
+          40,
+          11,
+          301,
+          0,
+          0,
+          0,
+          42,
+          86,
+          0,
+          0,
+          0,
+          0,
+          4,
+          27,
+          33,
+          0,
+          0
+        ],
+        [
+          0,
+          13,
+          0,
+          417,
+          0,
+          0,
+          1,
+          189,
+          0,
+          0,
+          0,
+          6,
+          88,
+          0,
+          111,
+          50,
+          48,
+          0,
+          603,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "add:0.25": {
+      "miou": 0.5256398451814701,
+      "oa": 0.7954606313128608,
+      "macro_f1": 0.6400266863319044,
+      "kappa": 0.7725060156424988,
+      "per_class_iou": [
+        0.7863696632193052,
+        0.7940560621411685,
+        0.8422681105804802,
+        0.5216035634743875,
+        0.8953563366655918,
+        0.5666403785488959,
+        0.6681021224238696,
+        0.6854425749817118,
+        0.3865969759193579,
+        0.15913978494623657,
+        0.8521227955584585,
+        0.16817463736895016,
+        0.15324165029469547,
+        0.3526720731960907,
+        0.8232323232323232,
+        0.5073836723321259,
+        0.010297482837528604,
+        0.2888170055452865
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14827,
+          104,
+          46,
+          8,
+          16,
+          20,
+          1,
+          480,
+          0,
+          3,
+          211,
+          80,
+          3,
+          659,
+          16,
+          296,
+          4,
+          6,
+          0
+        ],
+        [
+          0,
+          160,
+          11756,
+          93,
+          27,
+          17,
+          59,
+          3,
+          0,
+          18,
+          25,
+          184,
+          13,
+          1,
+          99,
+          0,
+          10,
+          4,
+          8,
+          0
+        ],
+        [
+          0,
+          165,
+          132,
+          12522,
+          19,
+          10,
+          2,
+          144,
+          0,
+          31,
+          1,
+          0,
+          2,
+          6,
+          113,
+          137,
+          34,
+          11,
+          539,
+          0
+        ],
+        [
+          0,
+          23,
+          477,
+          28,
+          1171,
+          50,
+          1,
+          0,
+          0,
+          0,
+          130,
+          0,
+          18,
+          10,
+          0,
+          2,
+          6,
+          128,
+          3,
+          0
+        ],
+        [
+          0,
+          83,
+          1,
+          23,
+          0,
+          5553,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          8,
+          1,
+          101,
+          0,
+          0
+        ],
+        [
+          0,
+          96,
+          76,
+          5,
+          7,
+          0,
+          1437,
+          49,
+          253,
+          0,
+          0,
+          217,
+          0,
+          0,
+          77,
+          0,
+          5,
+          186,
+          0,
+          0
+        ],
+        [
+          0,
+          7,
+          0,
+          14,
+          0,
+          0,
+          10,
+          4344,
+          415,
+          65,
+          0,
+          10,
+          472,
+          0,
+          33,
+          1,
+          4,
+          0,
+          4,
+          0
+        ],
+        [
+          0,
+          29,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          6559,
+          0,
+          0,
+          9,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          6,
+          20,
+          6,
+          0,
+          1,
+          0,
+          26,
+          0,
+          2071,
+          0,
+          0,
+          16,
+          14,
+          5,
+          1,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          34,
+          886,
+          0,
+          14,
+          0,
+          2,
+          0,
+          0,
+          5,
+          222,
+          0,
+          0,
+          0,
+          5,
+          0,
+          30,
+          4,
+          0,
+          0
+        ],
+        [
+          0,
+          17,
+          0,
+          0,
+          91,
+          0,
+          14,
+          5,
+          10,
+          0,
+          0,
+          6523,
+          0,
+          0,
+          13,
+          0,
+          63,
+          0,
+          6,
+          0
+        ],
+        [
+          0,
+          107,
+          18,
+          205,
+          0,
+          3,
+          10,
+          473,
+          524,
+          2954,
+          6,
+          129,
+          1171,
+          188,
+          120,
+          47,
+          11,
+          8,
+          72,
+          0
+        ],
+        [
+          0,
+          1,
+          44,
+          53,
+          0,
+          0,
+          0,
+          189,
+          8,
+          36,
+          1,
+          71,
+          216,
+          156,
+          12,
+          2,
+          7,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          1027,
+          18,
+          38,
+          0,
+          0,
+          10,
+          43,
+          402,
+          0,
+          0,
+          58,
+          0,
+          0,
+          1696,
+          0,
+          205,
+          7,
+          0,
+          0
+        ],
+        [
+          0,
+          28,
+          6,
+          32,
+          4,
+          6,
+          0,
+          0,
+          0,
+          40,
+          0,
+          0,
+          0,
+          0,
+          0,
+          1793,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          51,
+          0,
+          8,
+          0,
+          0,
+          0,
+          19,
+          875,
+          0,
+          0,
+          14,
+          0,
+          0,
+          41,
+          0,
+          1821,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          230,
+          546,
+          75,
+          28,
+          310,
+          0,
+          0,
+          0,
+          42,
+          27,
+          0,
+          0,
+          0,
+          0,
+          4,
+          15,
+          18,
+          0,
+          0
+        ],
+        [
+          0,
+          11,
+          0,
+          373,
+          0,
+          0,
+          0,
+          171,
+          4,
+          0,
+          0,
+          10,
+          100,
+          0,
+          109,
+          51,
+          72,
+          0,
+          625,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    },
+    "add:0.5": {
+      "miou": 0.5090612468206375,
+      "oa": 0.7875772538854554,
+      "macro_f1": 0.6261832418365842,
+      "kappa": 0.7636132382344394,
+      "per_class_iou": [
+        0.7859325605900949,
+        0.7847862672500842,
+        0.8417616097008461,
+        0.4688974688974689,
+        0.8888531446035065,
+        0.4957098283931357,
+        0.6741316270566727,
+        0.6773225739706187,
+        0.3778793418647166,
+        0.12577639751552794,
+        0.8244294275149815,
+        0.09631811487481591,
+        0.2294557097118463,
+        0.3591641271223335,
+        0.7114754098360656,
+        0.5004046398705152,
+        0.005789473684210527,
+        0.3150147203140334
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          14917,
+          80,
+          63,
+          1,
+          16,
+          9,
+          0,
+          521,
+          0,
+          2,
+          206,
+          70,
+          2,
+          557,
+          14,
+          316,
+          0,
+          6,
+          0
+        ],
+        [
+          0,
+          246,
+          11658,
+          100,
+          54,
+          18,
+          60,
+          1,
+          0,
+          17,
+          18,
+          183,
+          6,
+          1,
+          93,
+          0,
+          15,
+          2,
+          5,
+          0
+        ],
+        [
+          0,
+          161,
+          141,
+          12634,
+          13,
+          8,
+          2,
+          174,
+          2,
+          37,
+          8,
+          0,
+          16,
+          6,
+          56,
+          201,
+          29,
+          38,
+          342,
+          0
+        ],
+        [
+          0,
+          31,
+          532,
+          15,
+          1093,
+          50,
+          0,
+          0,
+          0,
+          0,
+          25,
+          0,
+          25,
+          11,
+          0,
+          6,
+          0,
+          259,
+          0,
+          0
+        ],
+        [
+          0,
+          99,
+          0,
+          22,
+          0,
+          5526,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          19,
+          4,
+          0,
+          119,
+          0,
+          0
+        ],
+        [
+          0,
+          120,
+          49,
+          9,
+          3,
+          0,
+          1271,
+          70,
+          222,
+          0,
+          2,
+          412,
+          0,
+          0,
+          77,
+          0,
+          5,
+          168,
+          0,
+          0
+        ],
+        [
+          0,
+          13,
+          0,
+          16,
+          0,
+          0,
+          12,
+          4425,
+          585,
+          9,
+          0,
+          9,
+          292,
+          0,
+          10,
+          0,
+          8,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          43,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          6547,
+          0,
+          0,
+          7,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          11,
+          14,
+          7,
+          1,
+          3,
+          0,
+          31,
+          2,
+          2067,
+          0,
+          0,
+          7,
+          4,
+          8,
+          11,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          67,
+          896,
+          9,
+          29,
+          1,
+          2,
+          0,
+          0,
+          4,
+          162,
+          0,
+          0,
+          0,
+          5,
+          0,
+          23,
+          4,
+          0,
+          0
+        ],
+        [
+          0,
+          20,
+          0,
+          0,
+          130,
+          0,
+          12,
+          7,
+          9,
+          0,
+          0,
+          6466,
+          0,
+          0,
+          20,
+          0,
+          75,
+          0,
+          3,
+          0
+        ],
+        [
+          0,
+          94,
+          20,
+          277,
+          0,
+          0,
+          53,
+          572,
+          453,
+          3118,
+          29,
+          158,
+          654,
+          117,
+          68,
+          242,
+          29,
+          6,
+          156,
+          0
+        ],
+        [
+          0,
+          13,
+          37,
+          62,
+          0,
+          0,
+          1,
+          145,
+          14,
+          30,
+          2,
+          31,
+          205,
+          215,
+          23,
+          10,
+          7,
+          1,
+          0,
+          0
+        ],
+        [
+          0,
+          1014,
+          16,
+          34,
+          0,
+          0,
+          5,
+          36,
+          417,
+          0,
+          0,
+          58,
+          0,
+          0,
+          1650,
+          0,
+          272,
+          2,
+          0,
+          0
+        ],
+        [
+          0,
+          48,
+          4,
+          51,
+          0,
+          4,
+          0,
+          0,
+          0,
+          58,
+          0,
+          0,
+          2,
+          0,
+          0,
+          1736,
+          0,
+          6,
+          0,
+          0
+        ],
+        [
+          0,
+          38,
+          0,
+          21,
+          0,
+          0,
+          0,
+          14,
+          825,
+          0,
+          0,
+          19,
+          0,
+          0,
+          57,
+          0,
+          1855,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          158,
+          589,
+          123,
+          53,
+          328,
+          0,
+          0,
+          0,
+          31,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          2,
+          11,
+          0,
+          0
+        ],
+        [
+          0,
+          24,
+          0,
+          332,
+          0,
+          0,
+          0,
+          135,
+          18,
+          0,
+          0,
+          18,
+          121,
+          0,
+          96,
+          43,
+          97,
+          0,
+          642,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    }
+  },
+  "seconds": 11.862706162035465,
+  "test_used_for_selection": false,
+  "model_count": 1
+}

main_method/configurations/32X32_recommended_validation_seed3407/test_results.json

@@ -0,0 +1,1883 @@
+{
+  "kind": "cnn_control",
+  "seed": 3407,
+  "mode": "add",
+  "alpha": 0.25,
+  "metrics": {
+    "miou": 0.49455547330691263,
+    "oa": 0.8109266736579659,
+    "macro_f1": 0.6234136021853756,
+    "kappa": 0.7642966739749818,
+    "per_class_iou": [
+      0.8061330522981268,
+      0.7198486670090578,
+      0.8757351877577422,
+      0.46213693236161063,
+      0.8703389461776095,
+      0.38416520104311963,
+      0.4490553274645572,
+      0.6216216216216216,
+      0.7901944411308601,
+      0.07114146695276376,
+      0.5587868716244287,
+      0.3175281724644782,
+      0.4373326486446833,
+      0.2655897022970766,
+      0.6168043633350977,
+      0.28662647573048294,
+      0.0918118400487935,
+      0.27714760156231727
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1311069,
+        6756,
+        8420,
+        815,
+        744,
+        883,
+        2246,
+        19285,
+        602,
+        381,
+        3742,
+        6998,
+        405,
+        29504,
+        1126,
+        71312,
+        1029,
+        686,
+        0
+      ],
+      [
+        0,
+        12671,
+        493367,
+        5115,
+        3930,
+        1130,
+        1764,
+        172,
+        746,
+        546,
+        21217,
+        15339,
+        437,
+        131,
+        1045,
+        166,
+        699,
+        2161,
+        44,
+        0
+      ],
+      [
+        0,
+        17785,
+        2752,
+        641744,
+        302,
+        960,
+        172,
+        3539,
+        862,
+        3810,
+        169,
+        19,
+        2132,
+        202,
+        3012,
+        4846,
+        607,
+        129,
+        5247,
+        0
+      ],
+      [
+        0,
+        9412,
+        46049,
+        1786,
+        82625,
+        1310,
+        4247,
+        55,
+        196,
+        62,
+        7994,
+        4414,
+        287,
+        376,
+        482,
+        80,
+        252,
+        3761,
+        4,
+        0
+      ],
+      [
+        0,
+        2675,
+        1166,
+        868,
+        380,
+        120018,
+        262,
+        124,
+        19,
+        220,
+        688,
+        194,
+        22,
+        35,
+        1476,
+        29,
+        106,
+        837,
+        0,
+        0
+      ],
+      [
+        0,
+        4040,
+        7283,
+        711,
+        3621,
+        289,
+        25338,
+        175,
+        883,
+        118,
+        2677,
+        5012,
+        146,
+        454,
+        1986,
+        330,
+        163,
+        536,
+        0,
+        0
+      ],
+      [
+        0,
+        1538,
+        141,
+        3611,
+        17,
+        249,
+        89,
+        47797,
+        7620,
+        3775,
+        49,
+        378,
+        1239,
+        1298,
+        2624,
+        9685,
+        632,
+        168,
+        1023,
+        0
+      ],
+      [
+        0,
+        18456,
+        124,
+        4622,
+        0,
+        0,
+        17,
+        1317,
+        151754,
+        0,
+        1,
+        338,
+        854,
+        23,
+        403,
+        328,
+        9076,
+        0,
+        164,
+        0
+      ],
+      [
+        0,
+        482,
+        193,
+        1058,
+        35,
+        123,
+        379,
+        620,
+        116,
+        66242,
+        0,
+        28,
+        795,
+        26,
+        446,
+        416,
+        71,
+        2,
+        15,
+        0
+      ],
+      [
+        0,
+        3092,
+        44739,
+        412,
+        1763,
+        216,
+        156,
+        5,
+        11,
+        5,
+        7062,
+        21,
+        6,
+        0,
+        299,
+        8,
+        83,
+        484,
+        0,
+        0
+      ],
+      [
+        0,
+        1322,
+        2401,
+        20,
+        0,
+        0,
+        1773,
+        184,
+        1235,
+        0,
+        143,
+        60525,
+        38,
+        0,
+        1508,
+        0,
+        693,
+        4,
+        114,
+        0
+      ],
+      [
+        0,
+        3196,
+        123,
+        4634,
+        46,
+        7,
+        910,
+        9697,
+        3978,
+        1955,
+        63,
+        3941,
+        25923,
+        639,
+        1593,
+        517,
+        2180,
+        171,
+        1142,
+        0
+      ],
+      [
+        0,
+        589,
+        140,
+        1406,
+        6,
+        31,
+        92,
+        2996,
+        519,
+        719,
+        7,
+        314,
+        2523,
+        11923,
+        406,
+        408,
+        473,
+        9,
+        52,
+        0
+      ],
+      [
+        0,
+        57524,
+        1032,
+        1194,
+        723,
+        333,
+        1050,
+        1045,
+        7046,
+        405,
+        646,
+        1114,
+        551,
+        254,
+        47497,
+        318,
+        6554,
+        377,
+        131,
+        0
+      ],
+      [
+        0,
+        1525,
+        170,
+        6485,
+        90,
+        129,
+        5,
+        653,
+        17,
+        376,
+        8,
+        2255,
+        478,
+        3,
+        400,
+        53604,
+        52,
+        13,
+        2053,
+        0
+      ],
+      [
+        0,
+        12728,
+        331,
+        778,
+        2,
+        0,
+        34,
+        422,
+        10506,
+        48,
+        33,
+        1127,
+        965,
+        73,
+        710,
+        23,
+        49018,
+        5,
+        56,
+        0
+      ],
+      [
+        0,
+        8636,
+        11253,
+        1214,
+        3447,
+        3258,
+        322,
+        34,
+        20,
+        20,
+        6827,
+        1,
+        610,
+        689,
+        1495,
+        80,
+        44,
+        4817,
+        2,
+        0
+      ],
+      [
+        0,
+        4694,
+        43,
+        2183,
+        220,
+        0,
+        39,
+        1222,
+        3590,
+        122,
+        2,
+        118,
+        2844,
+        42,
+        3653,
+        230,
+        1161,
+        11,
+        11850,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "reference": {
+    "miou": 0.4923823641221446,
+    "oa": 0.8069722305391867,
+    "macro_f1": 0.6220716182656123,
+    "kappa": 0.7604756314593856,
+    "per_class_iou": [
+      0.8075790627351255,
+      0.71292826214508,
+      0.8722037487999142,
+      0.49159387306580987,
+      0.8753945402194118,
+      0.3695274547328132,
+      0.44380969707996,
+      0.618820955172456,
+      0.7991021866100304,
+      0.09855478879306705,
+      0.5415849299975815,
+      0.3029233700492677,
+      0.38863181158919813,
+      0.2724438255931417,
+      0.623407163708818,
+      0.2832768116184144,
+      0.09794562774695224,
+      0.26315444454156106
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1299809,
+        7054,
+        7868,
+        1175,
+        742,
+        1048,
+        2568,
+        20005,
+        768,
+        615,
+        3295,
+        9943,
+        588,
+        30648,
+        989,
+        77038,
+        790,
+        1060,
+        0
+      ],
+      [
+        0,
+        9859,
+        479954,
+        4841,
+        4319,
+        1012,
+        2059,
+        205,
+        754,
+        550,
+        33703,
+        18399,
+        572,
+        489,
+        1251,
+        226,
+        886,
+        1549,
+        52,
+        0
+      ],
+      [
+        0,
+        16269,
+        3221,
+        635028,
+        530,
+        1075,
+        235,
+        5684,
+        971,
+        3614,
+        217,
+        25,
+        3166,
+        458,
+        4014,
+        4873,
+        892,
+        137,
+        7880,
+        0
+      ],
+      [
+        0,
+        7275,
+        39630,
+        1499,
+        88130,
+        1366,
+        5100,
+        62,
+        247,
+        69,
+        11784,
+        3859,
+        335,
+        391,
+        687,
+        59,
+        385,
+        2507,
+        7,
+        0
+      ],
+      [
+        0,
+        2038,
+        1202,
+        849,
+        339,
+        120091,
+        328,
+        119,
+        27,
+        241,
+        828,
+        257,
+        32,
+        36,
+        1857,
+        27,
+        150,
+        698,
+        0,
+        0
+      ],
+      [
+        0,
+        3661,
+        6519,
+        626,
+        3375,
+        331,
+        25102,
+        184,
+        884,
+        96,
+        3047,
+        5974,
+        179,
+        400,
+        2361,
+        321,
+        142,
+        560,
+        0,
+        0
+      ],
+      [
+        0,
+        1361,
+        139,
+        2822,
+        18,
+        239,
+        48,
+        48788,
+        7325,
+        2676,
+        106,
+        347,
+        1797,
+        1652,
+        3326,
+        9436,
+        691,
+        52,
+        1110,
+        0
+      ],
+      [
+        0,
+        17496,
+        131,
+        4134,
+        0,
+        0,
+        28,
+        1205,
+        151587,
+        5,
+        2,
+        256,
+        1490,
+        77,
+        484,
+        515,
+        9821,
+        3,
+        243,
+        0
+      ],
+      [
+        0,
+        232,
+        197,
+        1044,
+        38,
+        102,
+        354,
+        822,
+        23,
+        66220,
+        0,
+        30,
+        875,
+        53,
+        590,
+        363,
+        59,
+        0,
+        45,
+        0
+      ],
+      [
+        0,
+        2589,
+        40372,
+        432,
+        1697,
+        85,
+        183,
+        6,
+        6,
+        3,
+        11668,
+        128,
+        13,
+        0,
+        328,
+        9,
+        143,
+        700,
+        0,
+        0
+      ],
+      [
+        0,
+        1201,
+        2390,
+        12,
+        4,
+        0,
+        1850,
+        224,
+        1190,
+        0,
+        187,
+        60462,
+        122,
+        0,
+        1454,
+        0,
+        684,
+        0,
+        180,
+        0
+      ],
+      [
+        0,
+        2978,
+        119,
+        4039,
+        5,
+        14,
+        597,
+        9868,
+        3941,
+        1934,
+        59,
+        4827,
+        26869,
+        905,
+        1457,
+        341,
+        2151,
+        74,
+        537,
+        0
+      ],
+      [
+        0,
+        505,
+        118,
+        1280,
+        2,
+        27,
+        105,
+        3700,
+        479,
+        856,
+        19,
+        235,
+        2717,
+        11254,
+        430,
+        362,
+        482,
+        4,
+        38,
+        0
+      ],
+      [
+        0,
+        52630,
+        1153,
+        729,
+        599,
+        370,
+        1654,
+        912,
+        7181,
+        630,
+        800,
+        1006,
+        1038,
+        375,
+        49894,
+        305,
+        7834,
+        405,
+        279,
+        0
+      ],
+      [
+        0,
+        1535,
+        175,
+        5701,
+        139,
+        134,
+        10,
+        958,
+        53,
+        178,
+        19,
+        2044,
+        902,
+        13,
+        434,
+        53815,
+        96,
+        19,
+        2091,
+        0
+      ],
+      [
+        0,
+        10908,
+        344,
+        660,
+        5,
+        0,
+        48,
+        386,
+        10783,
+        50,
+        67,
+        797,
+        1211,
+        65,
+        427,
+        24,
+        50870,
+        10,
+        204,
+        0
+      ],
+      [
+        0,
+        8066,
+        9726,
+        1198,
+        3564,
+        2564,
+        469,
+        60,
+        10,
+        10,
+        8574,
+        2,
+        722,
+        769,
+        1940,
+        73,
+        83,
+        4925,
+        14,
+        0
+      ],
+      [
+        0,
+        4907,
+        45,
+        2050,
+        73,
+        5,
+        52,
+        1034,
+        3605,
+        141,
+        2,
+        198,
+        2870,
+        74,
+        3653,
+        85,
+        1181,
+        6,
+        12043,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "standalone": {
+    "miou": 0.4266778826213718,
+    "oa": 0.7752192943702201,
+    "macro_f1": 0.5556453126881764,
+    "kappa": 0.7186114394046562,
+    "per_class_iou": [
+      0.7790742463552546,
+      0.6869866622221532,
+      0.8210746853050781,
+      0.29118679756515975,
+      0.7695933297043243,
+      0.3177991046369946,
+      0.3580516175936023,
+      0.5833144784746076,
+      0.6887001682882521,
+      0.018319123020706457,
+      0.49909281098994684,
+      0.23546742913973148,
+      0.4093449011102125,
+      0.20079224079162106,
+      0.4989499074670936,
+      0.25451457866068566,
+      0.05835040080296228,
+      0.20958940505630608
+    ],
+    "confusion_matrix": [
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ],
+      [
+        0,
+        1300525,
+        7446,
+        16746,
+        2308,
+        1400,
+        1351,
+        2729,
+        18522,
+        559,
+        897,
+        5517,
+        3855,
+        355,
+        37587,
+        1894,
+        58630,
+        5186,
+        496,
+        0
+      ],
+      [
+        0,
+        23039,
+        486379,
+        7284,
+        6433,
+        2808,
+        2042,
+        157,
+        698,
+        520,
+        12018,
+        10775,
+        347,
+        539,
+        1408,
+        384,
+        493,
+        5261,
+        95,
+        0
+      ],
+      [
+        0,
+        24713,
+        2948,
+        621556,
+        294,
+        1044,
+        274,
+        1223,
+        1590,
+        6900,
+        1007,
+        185,
+        1938,
+        196,
+        3333,
+        11097,
+        403,
+        997,
+        8591,
+        0
+      ],
+      [
+        0,
+        16013,
+        61212,
+        1846,
+        54486,
+        5665,
+        5344,
+        92,
+        192,
+        27,
+        2264,
+        4833,
+        288,
+        293,
+        1139,
+        427,
+        200,
+        9059,
+        12,
+        0
+      ],
+      [
+        0,
+        4465,
+        1694,
+        1057,
+        631,
+        115930,
+        161,
+        59,
+        34,
+        269,
+        835,
+        429,
+        85,
+        83,
+        776,
+        71,
+        196,
+        2343,
+        1,
+        0
+      ],
+      [
+        0,
+        4481,
+        8265,
+        1232,
+        5124,
+        286,
+        23213,
+        171,
+        887,
+        172,
+        2091,
+        4177,
+        61,
+        437,
+        1715,
+        314,
+        219,
+        917,
+        0,
+        0
+      ],
+      [
+        0,
+        2027,
+        155,
+        6356,
+        139,
+        303,
+        1858,
+        38415,
+        7743,
+        4734,
+        680,
+        676,
+        2861,
+        774,
+        2074,
+        7390,
+        779,
+        3977,
+        992,
+        0
+      ],
+      [
+        0,
+        19888,
+        172,
+        7644,
+        2,
+        0,
+        76,
+        3726,
+        141795,
+        0,
+        12,
+        1116,
+        1569,
+        4,
+        1561,
+        668,
+        8079,
+        136,
+        1029,
+        0
+      ],
+      [
+        0,
+        2017,
+        159,
+        1358,
+        209,
+        2604,
+        273,
+        119,
+        276,
+        61795,
+        32,
+        24,
+        533,
+        87,
+        232,
+        937,
+        206,
+        176,
+        10,
+        0
+      ],
+      [
+        0,
+        4587,
+        46739,
+        582,
+        2043,
+        1039,
+        424,
+        18,
+        28,
+        21,
+        1504,
+        51,
+        143,
+        7,
+        325,
+        127,
+        30,
+        693,
+        1,
+        0
+      ],
+      [
+        0,
+        4310,
+        2697,
+        87,
+        95,
+        45,
+        3434,
+        197,
+        1499,
+        22,
+        95,
+        53915,
+        109,
+        118,
+        2015,
+        46,
+        1234,
+        30,
+        12,
+        0
+      ],
+      [
+        0,
+        3747,
+        198,
+        6434,
+        582,
+        63,
+        939,
+        10160,
+        4113,
+        2214,
+        200,
+        1886,
+        18941,
+        977,
+        3052,
+        2047,
+        2657,
+        391,
+        2114,
+        0
+      ],
+      [
+        0,
+        708,
+        200,
+        1622,
+        211,
+        39,
+        1482,
+        924,
+        575,
+        371,
+        187,
+        574,
+        2023,
+        11135,
+        558,
+        887,
+        392,
+        635,
+        90,
+        0
+      ],
+      [
+        0,
+        64737,
+        894,
+        2545,
+        1168,
+        1210,
+        726,
+        1486,
+        7208,
+        463,
+        98,
+        1609,
+        737,
+        135,
+        38879,
+        625,
+        4378,
+        628,
+        268,
+        0
+      ],
+      [
+        0,
+        1670,
+        191,
+        8498,
+        96,
+        138,
+        2,
+        774,
+        31,
+        1499,
+        44,
+        1876,
+        1311,
+        30,
+        786,
+        47990,
+        15,
+        341,
+        3024,
+        0
+      ],
+      [
+        0,
+        14944,
+        303,
+        1546,
+        2,
+        40,
+        144,
+        1018,
+        8687,
+        32,
+        16,
+        3998,
+        1102,
+        98,
+        5007,
+        20,
+        39717,
+        18,
+        167,
+        0
+      ],
+      [
+        0,
+        8815,
+        13995,
+        1557,
+        3471,
+        4775,
+        725,
+        14,
+        98,
+        207,
+        3232,
+        1,
+        482,
+        415,
+        458,
+        204,
+        15,
+        4302,
+        3,
+        0
+      ],
+      [
+        0,
+        3157,
+        41,
+        2320,
+        917,
+        60,
+        26,
+        2489,
+        3427,
+        670,
+        30,
+        339,
+        2281,
+        41,
+        3808,
+        728,
+        1265,
+        170,
+        10255,
+        0
+      ],
+      [
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0,
+        0
+      ]
+    ]
+  },
+  "records": {
+    "add:0.25": {
+      "miou": 0.49455547330691263,
+      "oa": 0.8109266736579659,
+      "macro_f1": 0.6234136021853756,
+      "kappa": 0.7642966739749818,
+      "per_class_iou": [
+        0.8061330522981268,
+        0.7198486670090578,
+        0.8757351877577422,
+        0.46213693236161063,
+        0.8703389461776095,
+        0.38416520104311963,
+        0.4490553274645572,
+        0.6216216216216216,
+        0.7901944411308601,
+        0.07114146695276376,
+        0.5587868716244287,
+        0.3175281724644782,
+        0.4373326486446833,
+        0.2655897022970766,
+        0.6168043633350977,
+        0.28662647573048294,
+        0.0918118400487935,
+        0.27714760156231727
+      ],
+      "confusion_matrix": [
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ],
+        [
+          0,
+          1311069,
+          6756,
+          8420,
+          815,
+          744,
+          883,
+          2246,
+          19285,
+          602,
+          381,
+          3742,
+          6998,
+          405,
+          29504,
+          1126,
+          71312,
+          1029,
+          686,
+          0
+        ],
+        [
+          0,
+          12671,
+          493367,
+          5115,
+          3930,
+          1130,
+          1764,
+          172,
+          746,
+          546,
+          21217,
+          15339,
+          437,
+          131,
+          1045,
+          166,
+          699,
+          2161,
+          44,
+          0
+        ],
+        [
+          0,
+          17785,
+          2752,
+          641744,
+          302,
+          960,
+          172,
+          3539,
+          862,
+          3810,
+          169,
+          19,
+          2132,
+          202,
+          3012,
+          4846,
+          607,
+          129,
+          5247,
+          0
+        ],
+        [
+          0,
+          9412,
+          46049,
+          1786,
+          82625,
+          1310,
+          4247,
+          55,
+          196,
+          62,
+          7994,
+          4414,
+          287,
+          376,
+          482,
+          80,
+          252,
+          3761,
+          4,
+          0
+        ],
+        [
+          0,
+          2675,
+          1166,
+          868,
+          380,
+          120018,
+          262,
+          124,
+          19,
+          220,
+          688,
+          194,
+          22,
+          35,
+          1476,
+          29,
+          106,
+          837,
+          0,
+          0
+        ],
+        [
+          0,
+          4040,
+          7283,
+          711,
+          3621,
+          289,
+          25338,
+          175,
+          883,
+          118,
+          2677,
+          5012,
+          146,
+          454,
+          1986,
+          330,
+          163,
+          536,
+          0,
+          0
+        ],
+        [
+          0,
+          1538,
+          141,
+          3611,
+          17,
+          249,
+          89,
+          47797,
+          7620,
+          3775,
+          49,
+          378,
+          1239,
+          1298,
+          2624,
+          9685,
+          632,
+          168,
+          1023,
+          0
+        ],
+        [
+          0,
+          18456,
+          124,
+          4622,
+          0,
+          0,
+          17,
+          1317,
+          151754,
+          0,
+          1,
+          338,
+          854,
+          23,
+          403,
+          328,
+          9076,
+          0,
+          164,
+          0
+        ],
+        [
+          0,
+          482,
+          193,
+          1058,
+          35,
+          123,
+          379,
+          620,
+          116,
+          66242,
+          0,
+          28,
+          795,
+          26,
+          446,
+          416,
+          71,
+          2,
+          15,
+          0
+        ],
+        [
+          0,
+          3092,
+          44739,
+          412,
+          1763,
+          216,
+          156,
+          5,
+          11,
+          5,
+          7062,
+          21,
+          6,
+          0,
+          299,
+          8,
+          83,
+          484,
+          0,
+          0
+        ],
+        [
+          0,
+          1322,
+          2401,
+          20,
+          0,
+          0,
+          1773,
+          184,
+          1235,
+          0,
+          143,
+          60525,
+          38,
+          0,
+          1508,
+          0,
+          693,
+          4,
+          114,
+          0
+        ],
+        [
+          0,
+          3196,
+          123,
+          4634,
+          46,
+          7,
+          910,
+          9697,
+          3978,
+          1955,
+          63,
+          3941,
+          25923,
+          639,
+          1593,
+          517,
+          2180,
+          171,
+          1142,
+          0
+        ],
+        [
+          0,
+          589,
+          140,
+          1406,
+          6,
+          31,
+          92,
+          2996,
+          519,
+          719,
+          7,
+          314,
+          2523,
+          11923,
+          406,
+          408,
+          473,
+          9,
+          52,
+          0
+        ],
+        [
+          0,
+          57524,
+          1032,
+          1194,
+          723,
+          333,
+          1050,
+          1045,
+          7046,
+          405,
+          646,
+          1114,
+          551,
+          254,
+          47497,
+          318,
+          6554,
+          377,
+          131,
+          0
+        ],
+        [
+          0,
+          1525,
+          170,
+          6485,
+          90,
+          129,
+          5,
+          653,
+          17,
+          376,
+          8,
+          2255,
+          478,
+          3,
+          400,
+          53604,
+          52,
+          13,
+          2053,
+          0
+        ],
+        [
+          0,
+          12728,
+          331,
+          778,
+          2,
+          0,
+          34,
+          422,
+          10506,
+          48,
+          33,
+          1127,
+          965,
+          73,
+          710,
+          23,
+          49018,
+          5,
+          56,
+          0
+        ],
+        [
+          0,
+          8636,
+          11253,
+          1214,
+          3447,
+          3258,
+          322,
+          34,
+          20,
+          20,
+          6827,
+          1,
+          610,
+          689,
+          1495,
+          80,
+          44,
+          4817,
+          2,
+          0
+        ],
+        [
+          0,
+          4694,
+          43,
+          2183,
+          220,
+          0,
+          39,
+          1222,
+          3590,
+          122,
+          2,
+          118,
+          2844,
+          42,
+          3653,
+          230,
+          1161,
+          11,
+          11850,
+          0
+        ],
+        [
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0,
+          0
+        ]
+      ]
+    }
+  },
+  "seconds": 486.47970066498965,
+  "test_used_for_selection": false,
+  "model_count": 1
+}

main_method/verification.json

@@ -0,0 +1,15 @@
+{
+  "python_files_compile": true,
+  "strict_checkpoint_loading": true,
+  "all_final_component_hashes_verified": true,
+  "original_vs_packaged_cpu_max_absolute_error": {
+    "sam": 0.0,
+    "original": 0.0,
+    "new": 0.0,
+    "attention": 0.0,
+    "feature_summaries": 0.0
+  },
+  "original_cuda_test_scores_preserved": true,
+  "packaging_gpu_reevaluation_performed": false,
+  "reason": "GPU driver currently unavailable; original recorded metrics are retained, not represented as newly reproduced GPU evaluations."
+}