Colorizer round6: source and write verification before training

experiments/decision-20260928-v2/PROTOCOL.md

@@ -0,0 +1,47 @@
+# Penultimate architecture and curriculum decision — 28 September 2026
+
+## Objective and decision scope
+Select one reproducible course for the user's next, longer training run. Prioritize coherent plausible colors, fewer within-surface patches, and retained color over recovering an unknowable original hue. Strictly fewer than 4,000,000 deployed learned parameters, including encoder and any selector. This screen cannot establish a universal architecture ceiling. No experimental model replaces root production weights during this pass.
+
+## Evidence audit
+The uploaded project log describes an older classification U-Net. Current production is round6 palette step9000 at base revision `1a9eb8af2754ad2329a24cfe50d388cb559441d0`, 3,994,676 parameters. The authoritative current repo revision before this pass was `26d731862cc0ea531e7198fa823cb09db25bd243`.
+
+The semantic encoder/palette change improved substantially over the old U-Net. Round7's easier-of-original-or-teacher objective selected original targets only 5.8–9.5% of the time; it did not learn explicit alternative outputs. Critic variants (including 27M, smaller, and dense critics) failed visual release review. A region auxiliary and repeating the same decoder did not produce a clear gain. These results motivate separating color ambiguity from spatial assignment, not another saturation/critic sweep.
+
+## Primary research and implications
+- Zhang et al., Colorful Image Colorization: https://richzhang.github.io/colorization/ — classification/rebalancing addresses uncertainty; pixel-wise decoding still needs spatial coordination. Earlier log language that classification is universally required was an overstatement: later palette regression already outperformed that baseline.
+- Deshpande et al., Learning Diverse Image Colorization: https://arxiv.org/abs/1612.01958 and https://arxiv.org/html/1612.01958v2 — low-dimensional color-field variables coordinate alternatives over long spatial distances. Motivates global modes instead of pixel noise.
+- Wang et al., PalGAN: https://arxiv.org/html/2210.11204v1 — probabilistic palette prediction and assignment separate ambiguity from boundary handling. This project's small palette model is not a PalGAN reproduction.
+- Lee et al., Stochastic Multiple Choice Learning: https://arxiv.org/abs/1606.07839 — winner-based learning supports distinct hypotheses, but oracle quality is not automatic-default quality. We explicitly measure the gap and train an image-only selector.
+- Mehta and Rastegari, MobileViTv2: https://arxiv.org/abs/2206.02680 — efficient global attention in a mobile encoder. Test the ImageNet-pretrained 0.75 variant as a distinct backbone challenger, with all deployment parameters counted.
+- Saharia et al., Palette: https://arxiv.org/abs/2111.05826 — diffusion supports colorization diversity. Not a justified final-run choice here without training/validating a compact denoiser; repeating the old decoder did not test diffusion. Excluded from this finite screen because establishing a from-scratch diffusion model and sampler is substantially larger work than these warm-started alternatives.
+
+## Controlled comparisons
+Six arms: single palette vs four coherent palettes, crossed with teacher / mixed-target / staged curriculum. Same MobileNet v3 initialization, fixed8192 training images, seeds, image-index batches, augmentation draws, AdamW, batch24, 3000 updates. Encoder LR1e-5, decoder LR1e-4, warmup150 and cosine decay to15%, weight decay0.01, frozen encoder BatchNorm, gradient norm cap1, BF16 forwards/FP32 losses. New mode tensors and selector are included in the decoder group. The multi head adds only1,156 parameters (3,995,832 total).
+
+Multi head: shared spatial masks and encoder; four latent palette variants; image-only score selects one complete output. Training loss is95% winner reconstruction +5% mean reconstruction +0.1 selector cross-entropy against the detached winning index. Reconstruction is L1/20 +0.25 sliced color distribution distance +0.1 boundary difference. Winner is selected per entire image, never per pixel. Report mode usage, between-mode diversity, default vs oracle losses and mode-switching under input resize. No original color is available to the runtime selector. No hue rotation, saturation bonus or unvalidated generated 'plausible' labels.
+
+Curricula:
+1. Teacher: deterministic cached DDColor artistic targets.
+2. Mixed: independently sample original photograph or teacher target with probability0.5 per image each update. Never average two hues and never pick the easier target. Both represent complete color proposals; teacher remains fallible.
+3. Staged: first15% teacher, next35% ramp original probability to0.5; final third adds35% mild spectral/film/noise augmentation plus same-mode resize consistency (mean coefficient0.1, computed every fourth update). This tests a curriculum bundle, not isolated causal effects of each component. Anchored reconstruction remains active to guard against consistency-induced gray collapse.
+
+Seventh arm: MobileViTv2-0.75 + single palette, copied compatible decoder weights and new lateral projections. 3,481,205 parameters.1000 extra teacher alignment updates, then3000 staged updates; encoder LR2e-5, decoder2e-4. Pretrained encoder pinned to the revision recorded in encoder_provenance.json. This is a practical challenger with unequal prior colorization training and an extra alignment stage, not a pure equal-initialization ablation. A negative short pilot does not prove the encoder incapable.
+
+## Data and evaluation
+Training subset sampled from existing filtered16,230-image Imagenette/COCO training pool; no new teacher expense. Existing target cache hashes and row IDs checked. Pin dataset revisions. New128 development and160 test images from COCO val/0001 exclude earlier round7, region, recurrent evaluation IDs and exact-byte training duplicates. Teacher/encoder upstream exposure and near duplicates remain possible. Fix splits before training. Choose each arm's candidate from evaluations every1000 updates on development only; test opened after choices frozen. Keep all evaluated checkpoints.
+
+Screen on ordinary and film-style grayscale. Record raw and guided patch metrics, chroma retention, missed color, spill, auxiliary original-color error, resize and flip sensitivity, latency, and image-bootstrap paired intervals. Gray output can win a smoothness metric; do not rank on patch score alone. Screening guardrails allow missed color/spill at most+1.5points, coverage at least95% baseline, and error at most110% baseline. These are diagnostic eligibility conditions, not proof of plausibility. All checkpoint scans are exploratory and intervals do not correct multiple comparisons.
+
+Visual review: 32 fixed fresh examples per group, archival photos never used as neutral targets, seven familiar probes, and aspect-preserving production-pipeline outputs. Label comparisons anonymously with saved keys; assistant review is qualitative, not an independent human preference study. Archive source URLs and checksums retained. A modest historical panel is not a representative archival benchmark.
+
+## Targeted fine-tuning and RL
+Late-stage robustness and consistency are tested rather than assumed helpful. No RL launched in this screen: no independently validated preference reward currently exists, and previous learned critics were exploitable. Prefer direct differentiable supervision for measurable consistency; if a later reward is proposed it must first rank coherent alternate hues above gray collapse and patchwork on held-out images. No claim that RL is intrinsically unsuitable.
+
+## Persistence, budget, and final selection
+One L4 job with60min hard limit and50min internal training deadline; all outputs checkpointed to this main-branch experiment folder with SHA256 download verification. Source/access/preflight checks before training. The first attempt was canceled before training after about12min because of repeated NPZ decompression. Corrected version2 materializes each cache once and logs data preparation. A separate confirmation, if warranted, is capped18min; total maximum hardware charges at the verified$0.80/h rate approximately$1.20, excluding no separate service purchases. Current account balance is not exposed by the connector. No automatic paid reruns.
+
+Choose architecture/curriculum from test plus visual review, with production baseline retained as an eligible fallback. If a candidate clearly wins, confirm against the matching control on a second seed or targeted ablation within the remaining cap. Save final_config.json and NEXT_PASS.md with exact checkpoints, source revisions, dataset/curriculum, learning rates, retention gates and validation instructions. The next pass starts the longer run and performs Space/model-card/repository work. This pass does not claim any longer run already completed.
+
+## Version2 corrections before training
+NPZ cache members are decompressed once per shard, not once per selected image; a synthetic equivalence and timing check is saved. MobileViT now uses a separate post-warmup curriculum step. Six additional National Archives inputs supplement the original historical panel. Version1 was canceled before any training checkpoint; its source/preflight remains for audit.

experiments/decision-20260928-v2/REVIEW_HANDOFF.md

@@ -0,0 +1,30 @@
+# Experimental pass handoff — 2026-09-28
+
+## Status
+Version1 job `6aba3fb36b030d633f69c572` was canceled before training to fix repeated NPZ decompression. The replacement runs the seven-arm suite. Source, architecture preflight, parameter counts and upload/download verification are already committed to `experiments/decision-20260928-v2` on main. At this handoff no trained candidate has been reviewed or approved. Do not describe the suite as complete or declare a winner without reading its outputs.
+
+Root production remains v3 at `1a9eb8af2754ad2329a24cfe50d388cb559441d0`. The next pass should review this suite before launching the final longer run. Never overwrite root model files merely because an experimental score is lower.
+
+## Exact procedure for selecting the final course
+1. Read status.json, failure.json if present, summary.json and candidates.json. Verify every candidate's actual steps and parameter count; a partial/timed-out screen cannot establish the missing comparison. All model counts include encoder and selector.
+2. Read each development result and selected test result. The test is newly held out from project training and listed prior evaluations; upstream encoder/teacher exposure and near duplicates cannot be excluded. Use paired intervals as exploratory diagnostics, not multiple-comparison-corrected proof.
+3. View comparison JPEGs **before reading their key.json files**. Inspect both full frames and useful crops. Review all 32 fixed COCO examples for single/multi groups, the encoder group, and actual-aspect production_test images. Log visible findings per image: incoherent hue changes on one surface, missing colour, boundary leakage, implausible skin/sky/foliage, whole-image colour cast. An alternate plausible clothing colour is not a failure simply because it differs from the original.
+4. View the seven probes, historical comparison images, and actual-aspect production_archive images. Read archive_sources.json to identify failed downloads; do not report attempted images as evaluated. Supplement with the six National Archives inputs whose source records are in `supplement/nara_sources.json`. These are evaluation-only. Never supervise historical grayscale inputs with zero chroma.
+5. Inspect multi diagnostics: all mode frequencies, diversity, default-v-oracle losses and resize/flip mode switches. An oracle-only gain is insufficient for automatic deployment. An optional alternatives UI may be valuable but must not conceal a worse default. Inspect MobileViT visual outputs in light of its shorter colourisation history; do not declare a universally inferior backbone from a short warm-start test.
+6. Prefer a candidate only if images show a consistent benefit without unacceptable loss of colour, and quantitative diagnostics do not reveal collapse. Retain v3 as the fallback. If one method looks clearly better, a second-seed matched confirmation is authorized within the **remaining** pass budget; maximum additional L4 runtime18min, not an unbounded rerun. Previous attempt used about12min; replacement capped60min at$0.80/h. Preserve all results before exit.
+7. Write REVIEW.md and final_config.json with the actual checkpoint path, immutable commit, architecture, complete parameter count, recipe, seed, dataset revisions, teacher-cache revision and validation evidence. If nothing wins, state that plainly and use the established palette architecture. Do not promise that longer continuation necessarily improves it.
+
+## Specific implementation caveats to carry forward
+- Single/multi arms: same initial encoder and decoder, index batches, learning rates and update counts. Staged augmentation changes random-number consumption late in training; its flip/target-choice draws are not identical to teacher/mix. This is a curriculum-bundle comparison.
+- MobileViT receives1000 teacher alignment steps plus3000 curriculum steps. Version2 uses the post-warmup curriculum step for both augmentation/target ramps and consistency, correcting the canceled first attempt.
+- Each arm's candidate can come from an earlier development checkpoint. optimizer.pt belongs to the **last** step, not necessarily that selected checkpoint. Start a new optimizer from selected candidate weights; never pair candidate weights with a mismatched optimizer.
+- Existing r7 loss uses teacher/original targets for supervision; neither original colour error nor patch score alone measures plausibility.
+- Do not add RL without an independently validated reward. Previous critic failures are project evidence for caution, not proof RL can never help.
+- Keep original-image luminance and aspect ratio through the established inference pipeline. Single/multi DecisionColorizer needs its own loader; root load_semantic cannot silently load a new architecture.
+- If deploying MobileViT, include its upstream Apple license/notice and appropriate pretrained-model attribution.
+
+## Inference compute experiment already inspected
+Seven real historical photographs were evaluated with unchanged v3 weights at256/384/512 input size and the existing radius8 filter. On the six new National Archives images, larger size notably improves the children-in-a-field image (more coherent green foliage and blue sky), and slightly clarifies some people. It does not fix the near-monochrome casts on machinery, street and interior scenes. The familiar powerhouse pipe retains uneven colouring and changes hue with size. Therefore higher resolution is useful in some cases but is not a general cure. At fixed radius8, its physical smoothing footprint also changes: do not call this an isolated network-resolution ablation. Record measured CPU times as local indicative timings, not a deployment latency guarantee; they include a second diagnostic forward.
+
+## Final-pass scope
+After evidence review, start one longer run on the selected course, with checkpoint retention, bounded runtime, early exit for non-finite losses, durable metrics and uploads. Final production promotion requires comparing its saved checkpoints visually to v3 and the selected pilot. Develop the Space/ZeroGPU app, requirements and model card, and clean the repository without removing experiments or the stable branch needed by the user. Never state that the model is mathematically optimal or that no improvement is possible under4M parameters.

experiments/decision-20260928-v2/SHA256SUMS.json

@@ -0,0 +1,22 @@
+{
+  "PROTOCOL.md": "7d73f476df74bf01b6ea93346fd08b98dde0456af62eda5b297b6a3044e33869",
+  "REVIEW_HANDOFF.md": "feae011a9a04136caf796224ae92e913eda5bc9e47c94a7dfea481e071bb58b2",
+  "source/data.py": "eb43b886fe45435841439c36646985f914386a48faa712fb6806accac2ad48e0",
+  "source/decision_model.py": "c7c4370d93bc52fdd363d6d4fcc684c317806d9b393bd969f9ee670a01487f27",
+  "source/inference.py": "0ac1f382205b42cef0afaa9173017fa660e6859194a65a61b9b9052c437cd476",
+  "source/legacy_eval.py": "dd7e8bd5f961dfb6f1c2ce98fac41824c5009188e306000b195e922e4ed03e58",
+  "source/metrics.py": "af0ac996f6be0a351a55e372fab637a0d06740afe4a744cb80d0eae56ec97f66",
+  "source/model.py": "4cc57f82ffd6378bdf23a088ce7a1ed56c09e5673de3ee5232b8ee1cacc9be0a",
+  "source/objectives.py": "133e85b6f2914c0e3803cc26a26fa29b779a49036219dd245c2ecfe0ba411e20",
+  "source/persistence.py": "8b26dd8acdc135ecbfcdd30b7f7723feb6008ac820c083403da1e820bdc15d33",
+  "source/r7.py": "019ea992052f0233954b86e06e31c85c74ca313e67a55ff7fb03248f8874aaf5",
+  "source/semantic_model.py": "b019358cbcaa214743cbd244d20eb6e59eeff0ab5264093ec0927be8529b25a2",
+  "source/spatial.py": "d13abe399ef049e21a6459a7003461afaae0c00e0c560262c6cf375de4c9884a",
+  "source/train_suite.py": "fe09629930b44a2ce4d630339b15f6cb3c09a4504de890df41016113163efb6a",
+  "status.json": "820e46a29d75ee397d8d2814ad0429cb3d300952f32030d83e06a4dc0b56f803",
+  "supplement/baseline_nara_resolution.json": "8920921e71ef95ed442495171a0ce229b5338170c5ccdf6d60e241fdd61cb570",
+  "supplement/baseline_resolution.json": "e770a0dff51460de711b05a2dcb107e128f8635f05284bc075816da8a44f51e2",
+  "supplement/cache_loader_check.json": "b7f282c99f9371b40f1a0b403bd31296ed1c93496d99ed60e144e088397f22f9",
+  "supplement/nara_sources.json": "d4551fb5857161ecd72be4f315dc9e643e33700827e7fcf51e90049a6ef0f6ba",
+  "supplement/resolution_review.py": "d942406942a5197b54db053ea696fc59ff8b5d0093d4e0b5817431db55e9d115"
+}

experiments/decision-20260928-v2/source/data.py

@@ -0,0 +1,116 @@
+"""Fixed color-bin semantics and reproducible dataset membership."""
+import hashlib
+import io
+import json
+from pathlib import Path
+import numpy as np
+from PIL import Image
+import pyarrow.parquet as pq
+from scipy.spatial import cKDTree
+from skimage.color import rgb2lab
+import torch
+from torch.utils.data import Dataset
+
+class ColorBins:
+    def __init__(self, centers, weights=None):
+        self.centers = np.asarray(centers, np.float32)
+        if self.centers.ndim != 2 or self.centers.shape[1] != 2:
+            raise ValueError("Expected Q by 2 color centers")
+        self.tree = cKDTree(self.centers)
+        self.weights = np.ones(len(self.centers), np.float32) if weights is None else np.asarray(weights,np.float32)
+
+    def encode(self, ab, k=5, sigma=5):
+        k = min(k, len(self.centers))
+        if sigma <= 0 or k < 1:
+            raise ValueError("Invalid encoding parameters")
+        dist, idx = self.tree.query(ab.reshape(-1,2), k=k)
+        dist, idx = dist.reshape(-1,k), idx.reshape(-1,k)
+        logw = -dist**2/(2*sigma**2)
+        logw -= logw.max(1, keepdims=True)
+        weight = np.exp(logw); weight /= weight.sum(1,keepdims=True)
+        shape = (*ab.shape[:-1], k)
+        return idx.reshape(shape).astype(np.int64), weight.reshape(shape).astype(np.float32)
+
+def load_table(path):
+    table = pq.read_table(path)
+    return table
+
+def validate_manifest(path, table, manifest):
+    with open(path,'rb') as f:
+        digest=hashlib.file_digest(f,'sha256').hexdigest()
+    if digest!=manifest['dataset_sha256'] or len(table)!=manifest['rows']:
+        raise ValueError('Dataset differs from pinned split manifest')
+    groups=[list(map(int,manifest[k])) for k in ['train','validation','test']]
+    if any(not g or len(g)!=len(set(g)) or min(g)<0 or max(g)>=len(table) for g in groups):
+        raise ValueError('Invalid or repeated indices in manifest')
+    if any(set(groups[i])&set(groups[j]) for i,j in [(0,1),(0,2),(1,2)]):
+        raise ValueError('Train/validation/test overlap')
+
+def decode_image(table, index):
+    obj = table['image'][int(index)].as_py()
+    return Image.open(io.BytesIO(obj['bytes'])).convert('RGB')
+
+def legacy_split(n, seed=0):
+    # Exactly reproduce datasets.Dataset.train_test_split(test_size=.05, seed=0).
+    order = np.random.default_rng(seed).permutation(n)
+    nval = int(np.ceil(.05*n))
+    return order[nval:], order[:nval]
+
+def stratified_subset(indices, labels, per_class, seed):
+    rng = np.random.default_rng(seed)
+    selected = []
+    for label in sorted(set(labels)):
+        group = np.asarray([i for i in indices if labels[i] == label])
+        selected.extend(rng.choice(group, min(per_class,len(group)), replace=False).tolist())
+    return np.asarray(selected, dtype=np.int64)
+
+class PhotoDataset(Dataset):
+    def __init__(self, table, indices, bins, size=256, augment=False):
+        self.table, self.indices, self.bins = table, list(map(int,indices)), bins
+        self.size, self.augment = size, augment
+
+    def __len__(self):
+        return len(self.indices)
+
+    def __getitem__(self, item):
+        # Keep square preprocessing for controlled comparison with historical runs.
+        # Production inference preserves aspect ratio separately.
+        image = decode_image(self.table,self.indices[item]).resize((self.size,self.size),Image.Resampling.BILINEAR)
+        arr = np.asarray(image,dtype=np.float32)/255
+        if self.augment and torch.rand(()) < .5:
+            arr = arr[:,::-1].copy()
+        lab = rgb2lab(arr).astype(np.float32)
+        idx, weight = self.bins.encode(lab[...,1:])
+        return (torch.from_numpy((lab[...,:1]/50-1).transpose(2,0,1).copy()),
+                torch.from_numpy(lab[...,1:].transpose(2,0,1).copy()),
+                torch.from_numpy(idx),torch.from_numpy(weight))
+
+def estimate_weights(table, indices, bins, mix=.7, limit=1000, seed=0):
+    """Re-estimate the prior ON checkpoint bins; never replace the bin vocabulary."""
+    if not 0 <= mix <= 1:
+        raise ValueError("Rebalance mixture must be in [0,1]")
+    rng=np.random.default_rng(seed)
+    chosen=rng.choice(indices,min(limit,len(indices)),replace=False)
+    counts=np.ones(len(bins.centers),np.float64)*1e-3
+    for index in chosen:
+        image=decode_image(table,index).resize((32,32))
+        ab=rgb2lab(np.asarray(image,dtype=np.float32)/255)[...,1:]
+        # Low chroma is a heuristic, not proof that an image was originally B&W.
+        if np.linalg.norm(ab,axis=-1).mean()<3:
+            continue
+        idx,weight=bins.encode(ab)
+        np.add.at(counts,idx.ravel(),weight.ravel())
+    prior=counts/counts.sum()
+    weights=1/((1-mix)*prior+mix/len(prior))
+    weights/=np.sum(prior*weights)
+    return weights.astype(np.float32),prior.astype(np.float32)
+
+def write_manifest(path, table, train, validation, test, dataset_sha256):
+    groups=[set(map(int,g)) for g in [train,validation,test]]
+    assert not groups[0]&groups[1] and not groups[0]&groups[2] and not groups[1]&groups[2]
+    content={'dataset':'johnowhitaker/imagenette2-320','dataset_sha256':dataset_sha256,
+        'rows':len(table),'split_seed':0,'legacy_holdout_fraction':.05,
+        'train':list(map(int,train)),'validation':list(map(int,validation)), 'test':list(map(int,test)),
+        'caveat':'Matches the recent seed-0 holdout; older upstream training exposure is not established.'}
+    Path(path).write_text(json.dumps(content,indent=2))
+    return content

experiments/decision-20260928-v2/source/decision_model.py

@@ -0,0 +1,117 @@
+"""Single / multiple coherent palettes, optional compact global-attention encoder.
+
+Original experiment inspired by diverse colorization and multiple-choice learning;
+not a reproduction. All deployed parameters, including the selector, are counted.
+"""
+import json
+from pathlib import Path
+import torch
+from torch import nn
+import torch.nn.functional as F
+from safetensors.torch import save_file, load_file
+from semantic_model import SemanticColorizer
+
+
+class DecisionColorizer(SemanticColorizer):
+    def __init__(self, modes=1, backbone='mobilenet', pretrained=False,
+                 encoder_revision=None, **kwargs):
+        super().__init__(pretrained=False, **kwargs)
+        self.modes = modes
+        self.backbone = backbone
+        d = self.config['width']; q = self.config['queries']
+        if backbone == 'mobilevit':
+            import timm
+            from huggingface_hub import hf_hub_download
+            name = 'mobilevitv2_075.cvnets_in1k'
+            overlay = None
+            if pretrained:
+                assert encoder_revision, 'Pin pretrained encoder revision'
+                filename = hf_hub_download('timm/'+name, 'model.safetensors', revision=encoder_revision)
+                overlay = {'file': filename, 'hf_hub_id': None}
+            self.encoder = timm.create_model(name, pretrained=pretrained,
+                pretrained_cfg_overlay=overlay, features_only=True, out_indices=(1,2,3,4))
+            self.lateral = nn.ModuleList([nn.Conv2d(c,d,1) for c in self.encoder.feature_info.channels()])
+            cfg = self.encoder.pretrained_cfg
+            self.rgb_mean.copy_(torch.tensor(cfg['mean']).view(1,3,1,1))
+            self.rgb_std.copy_(torch.tensor(cfg['std']).view(1,3,1,1))
+        if modes > 1:
+            self.mode_embeddings = nn.Parameter(torch.randn(modes,d)*.03)
+            self.mode_offsets = nn.Parameter(torch.zeros(modes,q,2))
+            # Whole-image palette alternatives; no independently sampled pixels.
+            with torch.no_grad():
+                a=torch.arange(modes)*2*torch.pi/modes
+                self.mode_offsets[:,:,0]=.025*a.cos()[:,None]
+                self.mode_offsets[:,:,1]=.025*a.sin()[:,None]
+            self.mode_score = nn.Linear(d,modes)
+            nn.init.zeros_(self.mode_score.weight);nn.init.zeros_(self.mode_score.bias)
+        self.config.update(architecture='DecisionColorizer', format_version=3,
+            modes=modes, backbone=backbone, encoder_revision=encoder_revision)
+        count = sum(p.numel() for p in self.parameters())
+        assert count < 4_000_000, count
+
+    def features(self,L):
+        h,w=L.shape[-2:]
+        x=F.pad(self.neutral_rgb(L),(0,(-w)%32,0,(-h)%32),mode='replicate')
+        x=(x-self.rgb_mean)/self.rgb_std
+        if self.backbone=='mobilevit':
+            fs=self.encoder(x)
+        else:
+            fs=[]
+            for i,layer in enumerate(self.encoder):
+                x=layer(x)
+                if i in [3,6,12,16]:fs.append(x)
+        projected=[layer(f) for layer,f in zip(self.lateral,fs)]
+        x=projected[-1]
+        for i in range(2,-1,-1):
+            x=self.refine[2-i](F.interpolate(x,size=projected[i].shape[-2:],mode='bilinear',align_corners=False)+projected[i])
+        memory=self.memory_norm(torch.cat([F.adaptive_avg_pool2d(f,(8,8)).flatten(2).transpose(1,2) for f in projected[1:]],1))
+        q=self.queries[None].expand(L.shape[0],-1,-1)
+        for block in self.query_blocks:q=block(q,memory)
+        q=self.query_norm(q)
+        masks=torch.einsum('bqd,bdhw->bqhw',q,self.pixel(x))/(self.config['width']**.5)
+        weights=F.softmax(masks.float(),dim=1)
+        residual=2*torch.tanh(self.residual(x).float())
+        return q,weights,residual,memory.mean(1)
+
+    def forward(self,L,return_details=False):
+        q,weights,residual,context=self.features(L)
+        if self.modes==1:
+            palette=80*torch.tanh(self.palette(q))[:,None]
+            scores=q.new_zeros((len(L),1))
+        else:
+            mq=q[:,None]+self.mode_embeddings[None,:,None]
+            palette=80*torch.tanh(self.palette(mq)+self.mode_offsets[None])
+            scores=self.mode_score(context)
+        outputs=torch.einsum('bqhw,bkqc->bkchw',weights,palette.float())+residual[:,None]
+        b,k,c,h,w=outputs.shape
+        full=F.interpolate(outputs.reshape(b*k,c,h,w),size=(h*4,w*4),mode='bilinear',align_corners=False)
+        full=full[...,:L.shape[-2],:L.shape[-1]].reshape(b,k,c,*L.shape[-2:])
+        default=full[torch.arange(b,device=L.device),scores.argmax(1)]
+        if return_details:
+            return {'output':default,'all':full,'scores':scores.float(),
+                    'weights':weights,'palette':palette.float()}
+        return default
+
+
+def initialize_from_v3(model,baseline):
+    old=baseline.state_dict();state=model.state_dict()
+    copied=[]
+    for k,v in old.items():
+        if model.backbone=='mobilevit' and (k.startswith(('encoder.','lateral.')) or k in ['rgb_mean','rgb_std']):continue
+        if k in state and v.shape==state[k].shape:
+            state[k]=v;copied.append(k)
+    model.load_state_dict(state,strict=True)
+    return copied
+
+
+def save_decision(m,path):
+    p=Path(path);p.mkdir(parents=True,exist_ok=True)
+    save_file({k:v.detach().cpu().contiguous() for k,v in m.state_dict().items()},str(p/'model.safetensors'))
+    (p/'config.json').write_text(json.dumps(m.config,indent=2))
+
+
+def load_decision(path,device='cpu'):
+    p=Path(path);cfg=json.loads((p/'config.json').read_text())
+    m=DecisionColorizer(**{k:cfg[k] for k in ['modes','backbone','width','queries','head','encoder_revision']})
+    m.load_state_dict(load_file(str(p/'model.safetensors')),strict=True)
+    return m.to(device).eval()

experiments/decision-20260928-v2/source/inference.py

@@ -0,0 +1,111 @@
+"""Aspect-preserving colourisation with a compact semantic model.
+
+Input and output are PIL images. No teacher, critic or second learned model is
+loaded. Original lightness and alpha are retained; out-of-gamut chroma is reduced.
+"""
+import json
+import math
+from pathlib import Path
+import numpy as np
+import torch
+import torch.nn.functional as F
+from PIL import Image, ImageOps
+from skimage.color import rgb2lab
+from semantic_model import load_semantic
+
+MAX_PIXELS = 12_000_000
+
+def load_colorizer(path, device='cpu'):
+    model = load_semantic(path, device)
+    count = sum(p.numel() for p in model.parameters())
+    if count >= 4_000_000:
+        raise ValueError('Model exceeds the four-million-parameter limit')
+    return model
+
+def box_mean(x, r):
+    return F.avg_pool2d(x, 2*r+1, 1, r, count_include_pad=False)
+
+def prepare(image, size=256):
+    if not isinstance(image, Image.Image):
+        raise TypeError('Expected a PIL image')
+    if not 128 <= int(size) <= 512:
+        raise ValueError('Input size must be between 128 and 512')
+    image = ImageOps.exif_transpose(image)
+    if image.width * image.height > MAX_PIXELS:
+        raise ValueError('Please resize the image to at most 12 megapixels')
+    alpha = np.asarray(image.getchannel('A')).copy() if 'A' in image.getbands() else None
+    rgb = np.asarray(image.convert('RGB'), dtype=np.float32) / 255
+    light = rgb2lab(rgb)[..., 0].astype(np.float32)
+    scale = min(int(size)/max(image.size), 1.)
+    shape = (max(8, round(image.height*scale)), max(8, round(image.width*scale)))
+    x = torch.from_numpy(light)[None,None]/50-1
+    small = F.interpolate(x, size=shape, mode='bilinear', align_corners=False, antialias=True)
+    return light, alpha, small
+
+@torch.inference_mode()
+def chroma_coefficients(model, small, radius=8):
+    if radius not in (0,4,8,12,16):
+        raise ValueError('Unsupported smoothing radius')
+    device = next(model.parameters()).device
+    L = small.to(device)
+    ab = model(L).float()
+    if not torch.isfinite(ab).all():
+        raise RuntimeError('Model returned non-finite colours')
+    if radius == 0:
+        return torch.zeros_like(ab).cpu(), ab.cpu()
+    guide = (L.float()+1)/2
+    mi, mp = box_mean(guide,radius), box_mean(ab,radius)
+    var = (box_mean(guide*guide,radius)-mi*mi).clamp_min(0)
+    cov = box_mean(guide*ab,radius)-mi*mp
+    a = cov/(var+.001)
+    b = mp-a*mi
+    # Coefficients are upsampled, then evaluated against original-resolution L.
+    return box_mean(a,radius).cpu(), box_mean(b,radius).cpu()
+
+def _linear_rgb(light, ab):
+    fy = (light+16)/116
+    f = np.stack([fy+ab[...,0]/500,fy,fy-ab[...,1]/200],axis=-1)
+    xyz = np.where(f>6/29,f**3,(f-4/29)*(3*(6/29)**2))
+    xyz *= np.array([.95047,1.,1.08883],np.float32)
+    matrix = np.array([[3.24048134,-1.53715152,-.49853633],[-.96925495,1.87599,.04155593],[.05564664,-.20404134,1.05731107]],np.float32)
+    return xyz @ matrix.T
+
+def render(light, alpha, coefficients, saturation=1.):
+    saturation = float(saturation)
+    if not math.isfinite(saturation) or not 0 <= saturation <= 1.5:
+        raise ValueError('Colour strength must be between 0 and 1.5')
+    a,b = [F.interpolate(v.float(),size=light.shape,mode='bilinear',align_corners=False)[0].permute(1,2,0).numpy() for v in coefficients]
+    ab = (a*(light[...,None]/100)+b)*saturation
+    # Binary-search chroma compression retains Lab hue and lightness.
+    linear = _linear_rgb(light,ab)
+    invalid = ((linear < -1e-5)|(linear > 1+1e-5)).any(-1)
+    if invalid.any():
+        L = light[invalid]; colors=ab[invalid];lo=np.zeros(len(L),np.float32);hi=np.ones(len(L),np.float32)
+        for _ in range(9):
+            mid=(lo+hi)/2; candidate=_linear_rgb(L,colors*mid[:,None])
+            valid=((candidate>=-1e-5)&(candidate<=1+1e-5)).all(-1)
+            lo=np.where(valid,mid,lo);hi=np.where(valid,hi,mid)
+        ab[invalid]=colors*lo[:,None]
+        linear[invalid]=_linear_rgb(L,ab[invalid])
+    linear=np.clip(linear,0,1)
+    rgb=np.where(linear<=.0031308,12.92*linear,1.055*np.power(linear,1/2.4)-.055)
+    pixels=np.uint8(np.clip(np.rint(rgb*255),0,255))
+    if alpha is not None: pixels=np.concatenate([pixels,alpha[...,None]],axis=-1)
+    return Image.fromarray(pixels)
+
+def colorize(model, image, size=256, radius=8, saturation=1.):
+    light,alpha,small=prepare(image,size)
+    return render(light,alpha,chroma_coefficients(model,small,radius),saturation)
+
+def main():
+    import argparse
+    parser=argparse.ArgumentParser(description='Compact photo colouriser')
+    parser.add_argument('input');parser.add_argument('output')
+    parser.add_argument('--model',default='.');parser.add_argument('--device',default='cpu')
+    parser.add_argument('--size',type=int,default=256);parser.add_argument('--saturation',type=float,default=1.)
+    args=parser.parse_args()
+    model=load_colorizer(args.model,args.device)
+    with Image.open(args.input) as image:
+        colorize(model,image,args.size,saturation=args.saturation).save(args.output)
+
+if __name__=='__main__':main()

experiments/decision-20260928-v2/source/legacy_eval.py

@@ -0,0 +1,150 @@
+"""Round 4: matched multiscale structure and DDColor distillation experiments."""
+import os,sys,json,time,random,hashlib,traceback,shutil
+from pathlib import Path
+import numpy as np
+import cv2
+from PIL import Image,ImageDraw
+from skimage import data as sample_data
+from skimage.color import rgb2lab,lab2rgb
+import pyarrow as pa
+import pyarrow.parquet as pq
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset,DataLoader
+from huggingface_hub import HfApi,hf_hub_download,PyTorchModelHubMixin
+from model import load_model,save_model
+from data import decode_image,ColorBins
+from metrics import soft_ce,per_image_metrics
+from spatial import guided_chroma
+
+OUT=Path('round6');OUT.mkdir(exist_ok=True)
+DURABLE=None
+START=time.monotonic();DEADLINE=START+3.5*3600
+DEVICE='cuda';SEED=409;STEPS=3000
+BASE_REV='704fa80d792c3d759db91daa00b2dcfe6f0f6412'
+BASE_HASH='0e4c417375684a044860f8af3ac3a2fb44e1a5729254ca33abda758ea71aea6e'
+TEACHER_ID='piddnad/ddcolor_artistic'
+torch.set_num_threads(6)
+
+def deadline():
+    if time.monotonic()>DEADLINE:raise TimeoutError('Graceful export before remote hard timeout')
+
+def gray_arrays(im,style='gray'):
+    im=im.resize((256,256),Image.Resampling.BILINEAR)
+    rgb=np.asarray(im,np.float32)/255
+    lab=rgb2lab(rgb).astype(np.float32)
+    if style=='film':
+        g=(rgb*np.array([.42,.45,.13],np.float32)).sum(-1)
+        g=np.clip((g**1.15-.5)*.8+.5,0,1)
+    else:g=np.asarray(im.convert('L'),np.float32)/255
+    # Feed the same neutral sRGB input to teacher and student.
+    gray=np.repeat(g[...,None],3,-1).astype(np.float32)
+    L=rgb2lab(gray)[...,0].astype(np.float32)
+    return (L[None]/50-1).copy(),lab[...,1:].transpose(2,0,1).copy(),gray
+
+class Photos(Dataset):
+    def __init__(self,table,ids,bins=None,cache=None,augment=False,style='gray'):
+        self.table,self.ids,self.bins,self.cache,self.augment,self.style=table,ids,bins,cache,augment,style
+    def __len__(self):return len(self.ids)
+    def __getitem__(self,k):
+        L,ab,gray=gray_arrays(decode_image(self.table,self.ids[k]),self.style)
+        teach=np.array(self.cache[k],np.float32) if self.cache is not None else np.zeros((2,64,64),np.float32)
+        if self.augment:
+            if random.random()<.5:L=L[...,::-1].copy();ab=ab[...,::-1].copy();teach=teach[...,::-1].copy()
+            if random.random()<.3:L=np.clip(L*random.uniform(.85,1.15)+random.uniform(-.08,.08),-1,1)
+        if self.bins is not None:
+            idx,w=self.bins.encode(ab.transpose(1,2,0));return torch.from_numpy(L),torch.from_numpy(ab),torch.from_numpy(idx),torch.from_numpy(w),torch.from_numpy(teach)
+        return torch.from_numpy(L),torch.from_numpy(ab),torch.from_numpy(gray.transpose(2,0,1)),self.ids[k]
+
+def patch_excess(p,t):
+    """Excess color differences across 4–64px regions, in target-flat areas."""
+    values=[]
+    for scale in [4,16]:
+        a=F.avg_pool2d(p,scale);b=F.avg_pool2d(t,scale)
+        for offset in [1,4]:
+            for dim in [-1,-2]:
+                x=a.narrow(dim,offset,a.shape[dim]-offset)-a.narrow(dim,0,a.shape[dim]-offset)
+                y=b.narrow(dim,offset,b.shape[dim]-offset)-b.narrow(dim,0,b.shape[dim]-offset)
+                dx=x.norm(dim=1);dy=y.norm(dim=1);mask=(dy<3).float()
+                values.append(((dx-dy-1).relu()*mask).sum((1,2))/mask.sum((1,2)).clamp_min(1))
+    return sum(values)/len(values)
+
+def structural_loss(p,t):
+    terms=[]
+    for scale in [4,16]:
+        a=F.avg_pool2d(p,scale);b=F.avg_pool2d(t,scale)
+        for offset in [1,4]:
+            for dim in [-1,-2]:
+                x=a.narrow(dim,offset,a.shape[dim]-offset)-a.narrow(dim,0,a.shape[dim]-offset)
+                y=b.narrow(dim,offset,b.shape[dim]-offset)-b.narrow(dim,0,b.shape[dim]-offset)
+                terms.append(F.smooth_l1_loss(x/10,y/10,beta=.3))
+    return sum(terms)/len(terms)
+
+def additional_losses(p,t,teacher):
+    small=F.avg_pool2d(p,4);target=F.avg_pool2d(t,4)
+    # Teacher is fallible; reduce guidance when it conflicts strongly with ground truth.
+    confidence=torch.exp(-(teacher-target).norm(dim=1,keepdim=True)/30).detach()
+    kd=(F.smooth_l1_loss(small/20,teacher/20,beta=.5,reduction='none')*confidence).mean()
+    neutral=(t.norm(dim=1)<3).float()
+    neutral_loss=(p.norm(dim=1)*neutral).sum()/neutral.sum().clamp_min(1)/20
+    return structural_loss(p,t),kd,neutral_loss
+
+def measure(L,p,t,raw=None):
+    r=per_image_metrics(L,p,t);C=p.norm(dim=1);T=t.norm(dim=1)
+    for name,mask,event in [('missed_color',T>12,C<5),('neutral_spill',T<3,C>10)]:
+        r[name]=(mask&event).sum((1,2))/mask.sum((1,2)).clamp_min(1)
+    r['color_coverage']=(C>10).float().mean((1,2));r['patch_excess']=patch_excess(p,t)
+    r['raw_patch_excess']=patch_excess(p if raw is None else raw,t)
+    return r
+
+@torch.inference_mode()
+def teacher_predict(teacher,gray):
+    gray=F.interpolate(gray.to(DEVICE),size=(512,512),mode='bilinear',align_corners=False)
+    # Full precision is deliberate: spectral normalization / attention are not assumed BF16-safe.
+    out=teacher(gray).float()
+    assert out.shape[1]==2 and torch.isfinite(out).all()
+    return F.interpolate(out,size=(256,256),mode='bilinear',align_corners=False)
+
+@torch.inference_mode()
+def evaluate(model,table,ids,is_teacher=False):
+    result={};model.eval()
+    for style in ['gray','film']:
+        rows=[]
+        for L,t,gray,indices in DataLoader(Photos(table,ids,style=style),batch_size=2 if is_teacher else 8,num_workers=4):
+            deadline();L,t=L.to(DEVICE),t.to(DEVICE)
+            raw=teacher_predict(model,gray) if is_teacher else model.decode(model(L),.38)
+            pred=raw if is_teacher else guided_chroma(L,raw,8)
+            metrics=measure(L,pred,t,raw)
+            for j,index in enumerate(indices):rows.append({'index':int(index)}|{k:float(v[j]) for k,v in metrics.items()})
+        keep=[x for x in rows if x['target_chroma']>=5]
+        result[style]={'n_total':len(rows),'n_color':len(keep),'summary':{k:float(np.mean([x[k] for x in keep])) for k in keep[0] if k!='index'},'per_image':rows}
+    return result
+
+def selection(result,baseline):
+    scores=[];eligible=True
+    for style in ['gray','film']:
+        s=result[style]['summary'];b=baseline[style]['summary']
+        eligible &= (s['ab_error']<=b['ab_error']*1.05 and s['neutral_spill']<=b['neutral_spill']+.01
+                     and s['missed_color']<=b['missed_color']+.01 and s['color_coverage']>=.95*b['color_coverage']
+                     and s['patch_excess']<.85*b['patch_excess'] and s['raw_patch_excess']<.9*b['raw_patch_excess'])
+        scores.append(s['patch_excess']/max(b['patch_excess'],1e-6)+.3*s['neutral_spill']+.2*s['ab_error']/b['ab_error'])
+    return float(np.mean(scores)),bool(eligible)
+
+@torch.inference_mode()
+def probes(model,tag,teacher=False):
+    names=['astronaut','coffee','chelsea','rocket','camera','coins','moon'];images=[]
+    for name in names:
+        original=Image.fromarray(getattr(sample_data,name)()).convert('RGB')
+        L,_,gray=gray_arrays(original);x=torch.from_numpy(L)[None].to(DEVICE)
+        ab=teacher_predict(model,torch.from_numpy(gray.transpose(2,0,1))[None]) if teacher else guided_chroma(x,model.decode(model(x),.38),8)
+        lab=np.concatenate([(L[0]*50+50)[...,None],ab[0].cpu().numpy().transpose(1,2,0)],-1)
+        rgb=np.uint8(np.clip(lab2rgb(lab),0,1)*255)
+        images.append((name,Image.fromarray(np.uint8(gray*255)),Image.fromarray(rgb)))
+    canvas=Image.new('RGB',(512,len(names)*280),'white');d=ImageDraw.Draw(canvas)
+    for i,(name,gray,col) in enumerate(images):
+        canvas.paste(gray,(0,i*280+24));canvas.paste(col,(256,i*280+24));d.text((4,i*280+4),name+' input | '+tag,fill='black')
+    canvas.save(OUT/(tag+'.jpg'),quality=90)
+
+def write(name,obj):
+    (OUT/name).write_text(json.dumps(obj,indent=2));return obj
+

experiments/decision-20260928-v2/source/metrics.py

@@ -0,0 +1,35 @@
+"""Metrics are fidelity/artifact proxies; none certifies plausible color by itself."""
+import numpy as np
+import torch
+
+def soft_ce(logits, idx, weights, class_weights=None):
+    # FP32 reduction under autocast; no full target distribution materialized.
+    logits=logits.float()
+    idx=idx.permute(0,3,1,2)
+    weights=weights.permute(0,3,1,2)
+    nll=-((logits.gather(1,idx)-logits.logsumexp(1,keepdim=True))*weights).sum(1)
+    if class_weights is not None:
+        nll=nll*class_weights[idx[:,0]]
+    return nll.mean()
+
+def per_image_metrics(L, pred, target):
+    error=(pred-target).square().sum(1).sqrt().mean((1,2))
+    chroma=pred.square().sum(1).sqrt().mean((1,2))
+    true_chroma=target.square().sum(1).sqrt().mean((1,2))
+    seams=[]
+    for dim in [-1,-2]:
+        dp=pred.diff(dim=dim).square().sum(1).sqrt()
+        dt=target.diff(dim=dim).square().sum(1).sqrt()
+        dl=L.diff(dim=dim).abs()[:,0]*50
+        # Penalize excess chroma discontinuity where luminance is flat.
+        mask=(dl<2).float()
+        seams.append(((dp-dt).relu()*mask).sum((1,2))/mask.sum((1,2)).clamp_min(1))
+    return {'ab_error':error,'chroma':chroma,'target_chroma':true_chroma,
+            'excess_chroma_edge':sum(seams)/2}
+
+def summarize(rows):
+    keys=['ce','ab_error','chroma','target_chroma','excess_chroma_edge']
+    result={k:float(np.mean([r[k] for r in rows])) for k in keys}
+    result['n']=len(rows)
+    result['chroma_ratio']=result['chroma']/max(result['target_chroma'],1e-9)
+    return result

experiments/decision-20260928-v2/source/model.py

@@ -0,0 +1,122 @@
+"""Shared, checkpoint-compatible Mini U-Net. Parameters remain under 4M."""
+import json
+import math
+from pathlib import Path
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from huggingface_hub import PyTorchModelHubMixin, snapshot_download
+from safetensors.torch import load_file, save_file
+def double_conv(in_ch, out_ch):
+    return nn.Sequential(
+        nn.Conv2d(in_ch, out_ch, 3, padding=1, bias=False),
+        nn.BatchNorm2d(out_ch),
+        nn.ReLU(inplace=True),
+        nn.Conv2d(out_ch, out_ch, 3, padding=1, bias=False),
+        nn.BatchNorm2d(out_ch),
+        nn.ReLU(inplace=True),
+    )
+
+
+class DilatedContextBlock(nn.Module):
+    def __init__(self, channels, mid_ch=96, dilations=(2, 4, 8)):
+        super().__init__()
+        self.proj_in = nn.Sequential(
+            nn.Conv2d(channels, mid_ch, 1, bias=False),
+            nn.BatchNorm2d(mid_ch),
+            nn.ReLU(inplace=True),
+        )
+        layers = []
+        for d in dilations:
+            layers += [
+                nn.Conv2d(mid_ch, mid_ch, 3, padding=d, dilation=d, bias=False),
+                nn.BatchNorm2d(mid_ch),
+                nn.ReLU(inplace=True),
+            ]
+        self.dilated = nn.Sequential(*layers)
+        self.proj_out = nn.Sequential(
+            nn.Conv2d(mid_ch, channels, 1, bias=False),
+            nn.BatchNorm2d(channels),
+        )
+        nn.init.zeros_(self.proj_out[-1].weight)
+        self.relu = nn.ReLU(inplace=True)
+
+    def forward(self, x):
+        y = self.proj_in(x)
+        y = self.dilated(y)
+        y = self.proj_out(y)
+        return self.relu(x + y)
+
+
+class SmallUNetColorizer(
+    nn.Module,
+    PyTorchModelHubMixin,
+    pipeline_tag="image-to-image",
+    license="apache-2.0",
+    tags=["colorization", "unet", "image-to-image", "classification"],
+):
+    def __init__(self, bin_centers, in_ch: int = 1, base: int = 44,
+                 context_mid_ch: int = 96, context_dilations=(2, 4, 8)):
+        super().__init__()
+        self.in_ch, self.base = in_ch, base
+        num_bins = len(bin_centers)
+        self.num_bins = num_bins
+        self.register_buffer("bin_centers", torch.tensor(bin_centers, dtype=torch.float32))
+
+        self.enc1 = double_conv(in_ch, base)
+        self.enc2 = double_conv(base, base * 2)
+        self.enc3 = double_conv(base * 2, base * 4)
+        self.enc4 = double_conv(base * 4, base * 8)
+        self.pool = nn.MaxPool2d(2)
+        self.context = DilatedContextBlock(base * 8, mid_ch=context_mid_ch,
+                                            dilations=tuple(context_dilations))
+        self.up3 = nn.ConvTranspose2d(base * 8, base * 4, 2, stride=2)
+        self.dec3 = double_conv(base * 8, base * 4)
+        self.up2 = nn.ConvTranspose2d(base * 4, base * 2, 2, stride=2)
+        self.dec2 = double_conv(base * 4, base * 2)
+        self.up1 = nn.ConvTranspose2d(base * 2, base, 2, stride=2)
+        self.dec1 = double_conv(base * 2, base)
+        self.out_conv = nn.Conv2d(base, num_bins, 1)
+
+    def forward(self, x):
+        h, w = x.shape[-2:]
+        x = F.pad(x, (0, (-w) % 8, 0, (-h) % 8), mode="replicate")
+        e1 = self.enc1(x)
+        e2 = self.enc2(self.pool(e1))
+        e3 = self.enc3(self.pool(e2))
+        e4 = self.context(self.enc4(self.pool(e3)))
+        d3 = self.dec3(torch.cat([self.up3(e4), e3], dim=1))
+        d2 = self.dec2(torch.cat([self.up2(d3), e2], dim=1))
+        d1 = self.dec1(torch.cat([self.up1(d2), e1], dim=1))
+        return self.out_conv(d1)[..., :h, :w]
+
+    def decode(self, logits, temperature: float = 0.38):
+        if not math.isfinite(temperature) or temperature <= 0:
+            raise ValueError("temperature must be finite and positive")
+        probs_t = F.softmax(logits.float() / temperature, dim=1)
+        return torch.einsum("bqhw,qc->bchw", probs_t, self.bin_centers)
+
+
+def load_model(source, revision=None, device="cpu"):
+    path = Path(source)
+    if not path.is_dir():
+        path = Path(snapshot_download(source, revision=revision,
+            allow_patterns=["config.json", "model.safetensors"]))
+    config = json.loads((path / "config.json").read_text())
+    state = load_file(str(path / "model.safetensors"))
+    centers = torch.tensor(config["bin_centers"], dtype=torch.float32)
+    if not torch.equal(centers, state["bin_centers"]):
+        raise ValueError("Checkpoint config and state color bins differ; refusing ambiguous decode")
+    model = SmallUNetColorizer(**config)
+    model.load_state_dict(state, strict=True)
+    model.to(device).eval()
+    return model
+
+def save_model(model, path):
+    path = Path(path); path.mkdir(parents=True, exist_ok=True)
+    model.save_pretrained(path)
+    # Mixin config can retain constructor bins; use the actual authoritative buffer.
+    cfg = json.loads((path / "config.json").read_text())
+    cfg["bin_centers"] = model.bin_centers.detach().cpu().tolist()
+    (path / "config.json").write_text(json.dumps(cfg, indent=2))

experiments/decision-20260928-v2/source/objectives.py

@@ -0,0 +1,17 @@
+import math
+import torch
+import torch.nn.functional as F
+
+def color_loss(pred,target):
+    """Fit one coherent target; distribution matching discourages gray averages."""
+    pred=F.adaptive_avg_pool2d(pred,(64,64)).float();target=target.float()
+    pixel=F.l1_loss(pred/20,target/20)
+    p=F.avg_pool2d(pred,2).flatten(2);t=F.avg_pool2d(target,2).flatten(2)
+    angle=torch.arange(8,device=p.device,dtype=p.dtype)*math.pi/8
+    directions=torch.stack([angle.cos(),angle.sin()],1)
+    a=torch.einsum('kc,bcn->bkn',directions,p).sort(-1).values
+    b=torch.einsum('kc,bcn->bkn',directions,t).sort(-1).values
+    distribution=F.l1_loss(a/20,b/20)
+    # Match boundaries in the teacher target, never minimize gradients toward zero.
+    edge=(F.l1_loss((pred[:,:,:,1:]-pred[:,:,:,:-1])/20,(target[:,:,:,1:]-target[:,:,:,:-1])/20)+F.l1_loss((pred[:,:,1:]-pred[:,:,:-1])/20,(target[:,:,1:]-target[:,:,:-1])/20))/2
+    return pixel+.25*distribution+.1*edge,{'pixel':pixel,'distribution':distribution,'edge':edge}

experiments/decision-20260928-v2/source/persistence.py

@@ -0,0 +1,42 @@
+"""Commit run artifacts atomically and verify every changed file by SHA256."""
+import hashlib, json, os, time
+from pathlib import Path
+from huggingface_hub import HfApi, CommitOperationAdd, hf_hub_download
+
+REPO = 'User-2468/mini-unet-colorizer'
+PREFIX = 'experiments/round6-20260928'
+
+class DurableRun:
+    def __init__(self, root):
+        if not os.environ.get('HF_TOKEN'):
+            raise RuntimeError('A write token is required before starting')
+        self.api = HfApi(token=os.environ['HF_TOKEN'])
+        if self.api.whoami()['name'] != 'User-2468':
+            raise RuntimeError('Unexpected account')
+        self.root = Path(root)
+        self.saved = {}
+
+    def sync(self, reason):
+        files = [p for p in sorted(self.root.rglob('*')) if p.is_file()]
+        hashes = {p.relative_to(self.root).as_posix(): hashlib.sha256(p.read_bytes()).hexdigest() for p in files}
+        changed = [p for p in files if self.saved.get(p.relative_to(self.root).as_posix()) != hashes[p.relative_to(self.root).as_posix()]]
+        if not changed:
+            return
+        for attempt in range(3):
+            try:
+                head = self.api.model_info(REPO, revision='main').sha
+                operations = [CommitOperationAdd(path_in_repo=PREFIX+'/'+p.relative_to(self.root).as_posix(), path_or_fileobj=str(p)) for p in changed]
+                operations.append(CommitOperationAdd(path_in_repo=PREFIX+'/SHA256SUMS.json', path_or_fileobj=json.dumps(hashes,sort_keys=True,indent=2).encode()))
+                commit = self.api.create_commit(repo_id=REPO, revision='main', parent_commit=head, operations=operations, commit_message='Colorizer round6: '+reason)
+                for p in changed:
+                    name = p.relative_to(self.root).as_posix()
+                    downloaded = hf_hub_download(REPO, PREFIX+'/'+name, revision=commit.oid, force_download=True, token=os.environ['HF_TOKEN'])
+                    if hashlib.sha256(Path(downloaded).read_bytes()).hexdigest() != hashes[name]:
+                        raise RuntimeError('Remote checksum mismatch: '+name)
+                self.saved = hashes
+                print('PERSISTED',reason,commit.oid,'verified_files',len(changed),flush=True)
+                return
+            except Exception:
+                if attempt == 2:
+                    raise
+                time.sleep(2**attempt)

experiments/decision-20260928-v2/source/r7.py

@@ -0,0 +1,234 @@
+import os,sys,json,random,time,hashlib,shutil,math,traceback,io
+from pathlib import Path
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import Dataset,DataLoader
+from huggingface_hub import hf_hub_download
+import pyarrow as pa
+import pyarrow.parquet as pq
+from PIL import Image,ImageDraw
+from skimage.color import rgb2lab,lab2rgb
+from skimage.segmentation import slic
+import cv2
+import persistence
+from semantic_model import load_semantic,save_semantic
+from objectives import color_loss
+from data import decode_image
+import legacy_eval as ev
+REPO='User-2468/mini-unet-colorizer'
+REV='7b10485ee9d205ce2f7b660dfc6a90012d78b1cb'
+OLD='experiments/round6-20260928'
+OUT=Path('/work/results');OUT.mkdir(parents=True,exist_ok=True)
+persistence.PREFIX='experiments/round7-20260928'
+ev.OUT=OUT
+START=time.monotonic()
+SEED=709
+STEPS=2000
+DEVICE='cpu' if os.environ.get('SMOKE')=='1' else 'cuda'
+ev.DEVICE=DEVICE
+DURABLE=None
+def write(name,obj):
+ p=OUT/name;p.parent.mkdir(parents=True,exist_ok=True);p.write_text(json.dumps(obj,indent=2));return obj
+def deadline():
+ if time.monotonic()-START>9000:raise TimeoutError('Graceful deadline')
+ev.deadline=deadline
+def losses(p,t):
+ p=F.adaptive_avg_pool2d(p.float(),(64,64));t=t.float()
+ pixel=(p-t).abs().mean((1,2,3))/20
+ a=F.avg_pool2d(p,2).flatten(2);b=F.avg_pool2d(t,2).flatten(2)
+ angles=torch.arange(8,device=p.device)*math.pi/8
+ directions=torch.stack([angles.cos(),angles.sin()],1)
+ ap=torch.einsum('kc,bcn->bkn',directions,a).sort(-1).values
+ bp=torch.einsum('kc,bcn->bkn',directions,b).sort(-1).values
+ distribution=(ap-bp).abs().mean((1,2))/20
+ edge=((torch.diff(p,dim=-1)-torch.diff(t,dim=-1)).abs().mean((1,2,3))+(torch.diff(p,dim=-2)-torch.diff(t,dim=-2)).abs().mean((1,2,3)))/40
+ return pixel+.25*distribution+.1*edge
+def select_loss(p,teacher,original,mode):
+ a=losses(p,teacher)
+ if mode=='teacher':return a.mean(),torch.zeros_like(a,dtype=torch.bool)
+ b=losses(p,original);choose=b<a
+ return torch.where(choose,b,a).mean(),choose
+def smoke():
+ torch.set_num_threads(4);torch.manual_seed(SEED)
+ p=torch.randn(2,2,64,64,requires_grad=True);t=torch.randn_like(p)
+ assert torch.allclose(losses(p,t).mean(),color_loss(p,t)[0],atol=1e-6)
+ # Whole-image choice: exact red or blue is better than an average or a patchwork.
+ red=torch.zeros(1,2,64,64);red[:,0]=30
+ blue=-red;mix=red.clone();mix[:,:,:,32:]=blue[:,:,:,32:]
+ assert select_loss(red,red,blue,'set')[0]==0
+ assert select_loss(torch.zeros_like(red),red,blue,'set')[0]>0
+ assert select_loss(mix,red,blue,'set')[0]>0
+ m=load_semantic('/work/initial',DEVICE)
+ assert sum(p.numel() for p in m.parameters())==3994676
+ x=torch.rand(2,1,96,128,device=DEVICE)*2-1
+ pred=m(x);loss,_=select_loss(pred,t.to(DEVICE),-t.to(DEVICE),'set')
+ loss.backward()
+ assert torch.isfinite(loss) and all(torch.isfinite(p.grad).all() for p in m.parameters() if p.grad is not None)
+ save_semantic(m,OUT/'initial')
+ re=load_semantic(OUT/'initial',DEVICE)
+ with torch.no_grad():assert torch.allclose(m.eval()(x),re(x),atol=1e-5)
+ write('smoke.json',{'passed':True,'parameters':3994676,'loss_equivalence':True,'whole_image_choice':True,'finite_backward':True,'reload':True})
+ del m,re
+class Photos(Dataset):
+ def __init__(self,table,ids,cache,archive):
+  self.table,self.ids,self.cache,self.archive=table,ids,cache,archive;self.epoch=0
+ def __len__(self):return len(self.ids)
+ def __getitem__(self,k):
+  im=decode_image(self.table,self.ids[k]);L,ab,gray=ev.gray_arrays(im)
+  # Independent per-example RNG; augmentation differences never alter image ordering/flips.
+  rng=np.random.default_rng(np.random.SeedSequence([SEED,self.epoch,k]))
+  target=np.array(self.cache[k],np.float32)
+  if self.archive and rng.random()<.5:
+   rgb=np.asarray(im.resize((256,256),Image.Resampling.BILINEAR),np.float32)/255
+   weights=rng.dirichlet(np.array([3.,5.,2.]))
+   g=(rgb*weights).sum(-1)
+   g=np.clip((g**rng.uniform(.7,1.5)-.5)*rng.uniform(.6,1.1)+.5+rng.uniform(-.08,.08),0,1)
+   if rng.random()<.5:g=cv2.GaussianBlur(g,(5,5),float(rng.uniform(.3,1.2)))
+   if rng.random()<.6:g=np.clip(g+rng.normal(0,rng.uniform(.003,.025),g.shape),0,1)
+   L=(rgb2lab(np.repeat(g[...,None],3,-1).astype(np.float32))[...,0][None]/50-1).astype(np.float32)
+  else:
+   if rng.random()<.5:L=np.clip(L*rng.uniform(.7,1.15)+rng.uniform(-.12,.12),-1,1)
+  flip=np.random.default_rng(np.random.SeedSequence([SEED+1,self.epoch,k])).random()<.5
+  if flip:L=L[...,::-1].copy();ab=ab[...,::-1].copy();target=target[...,::-1].copy()
+  original=cv2.resize(ab.transpose(1,2,0),(64,64),interpolation=cv2.INTER_AREA).transpose(2,0,1).copy()
+  return torch.from_numpy(L),torch.from_numpy(target),torch.from_numpy(original)
+@torch.inference_mode()
+def predict(m,L):
+ x=torch.from_numpy(L)[None].to(DEVICE);raw=m(x)
+ guided=ev.guided_chroma(x,raw,8)
+ return raw,guided
+def toimage(L,ab):
+ rgb=lab2rgb(np.concatenate([(L[0]*50+50)[...,None],ab],-1))
+ return Image.fromarray(np.uint8(np.clip(rgb,0,1)*255))
+@torch.inference_mode()
+def review(m,table,ids,name):
+ m.eval();rows=[]
+ # Reference-derived surface regions for diagnostics only, never inference.
+ for i in ids:
+  L,target,_=ev.gray_arrays(decode_image(table,i))
+  raw,pred=predict(m,L);x=torch.from_numpy(L)[None].to(DEVICE)
+  resize=F.interpolate(x,(224,224),mode='bilinear',align_corners=False)
+  resized=F.interpolate(m(resize),(256,256),mode='bilinear',align_corners=False)
+  contrast=m((x*.95+.02).clamp(-1,1))
+  pab=pred[0].cpu().numpy().transpose(1,2,0)
+  rgb=np.asarray(decode_image(table,i).resize((256,256)),np.float32)/255
+  seg=slic(rgb,n_segments=100,compactness=10,start_label=0)
+  tab=target.transpose(1,2,0);variations=[]
+  for label in np.unique(seg):
+   mask=seg==label
+   if mask.sum()<64:continue
+   ground=tab[mask];center=np.median(ground,axis=0)
+   if np.percentile(np.linalg.norm(ground-center,axis=1),90)>5:continue
+   col=pab[mask];variations.append(float(np.mean(np.linalg.norm(col-np.median(col,axis=0),axis=1))))
+  rows.append({'id':int(i),'resize_ab_change':float((raw-resized).abs().mean()),'contrast_ab_change':float((raw-contrast).abs().mean()),'surface_chroma_variation':float(np.mean(variations)) if variations else None,'chroma_coverage':float((pred.norm(dim=1)>10).float().mean()),'mean_chroma':float(pred.norm(dim=1).mean())})
+ write(name+'_diagnostics.json',{'rows':rows,'summary':{k:float(np.mean([r[k] for r in rows if r[k] is not None])) for k in rows[0] if k!='id'},'warning':'Surface uniformity alone rewards grey collapse; never use alone to select model. Color differences from original are diagnostic only.'})
+ return rows
+@torch.inference_mode()
+def grid(models,table,ids,label):
+ order=np.random.default_rng(SEED+2).permutation(len(models))
+ names=list(models);key={chr(65+j):names[int(i)] for j,i in enumerate(order)}
+ write(label+'_key.json',key)
+ for page in range(0,min(len(ids),32),8):
+  chosen=ids[page:page+8];canvas=Image.new('RGB',(256*(len(models)+1),274*len(chosen)),'white');draw=ImageDraw.Draw(canvas)
+  for row,index in enumerate(chosen):
+   L,_,gray=ev.gray_arrays(decode_image(table,index));draw.text((2,row*274),f'{index}: gray | '+' | '.join(key),fill='black')
+   canvas.paste(Image.fromarray(np.uint8(gray*255)),(0,row*274+18))
+   for j,i in enumerate(order):
+    _,p=predict(models[names[int(i)]],L)
+    canvas.paste(toimage(L,p[0].cpu().numpy().transpose(1,2,0)),((j+1)*256,row*274+18))
+  canvas.save(OUT/f'{label}_{page//8}.jpg',quality=92)
+def main():
+ global DURABLE
+ torch.set_num_threads(6);torch.manual_seed(SEED);random.seed(SEED);np.random.seed(SEED)
+ DURABLE=persistence.DurableRun(OUT)
+ shutil.copy2('/work/runner.py',OUT/'runner.py');shutil.copy2('/work/PROTOCOL.md',OUT/'PROTOCOL.md')
+ shutil.copytree('/work/source',OUT/'source',ignore=shutil.ignore_patterns('__pycache__'),dirs_exist_ok=True)
+ smoke();DURABLE.sync('round7 initial checkpoint and smoke verified')
+ if DEVICE=='cpu':return
+ torch.backends.cudnn.benchmark=True
+ tables=[]
+ for repo,rev,files in [('johnowhitaker/imagenette2-320','771c1310a2487e8076ede6b7d6307244aa8400af',['default/train/0000.parquet']),('detection-datasets/coco','26ddc382fe75dfc2a0655b5977e296ea10efebce',['default/train/0000.parquet','default/train/0001.parquet'])]:
+  for f in files:tables.append(pq.read_table(hf_hub_download(repo,f,repo_type='dataset',revision=rev),columns=['image']))
+ table=pa.concat_tables(tables);manifest=json.loads(Path('/work/source/previous_manifest.json').read_text());ids=manifest['train']
+ cache=np.empty((len(ids),2,64,64),np.float16)
+ sums=json.loads(Path(hf_hub_download(REPO,OLD+'/SHA256SUMS.json',revision=REV)).read_text())
+ for start in range(0,len(ids),2048):
+  f=f'teacher_cache/{start:05d}.npz';path=Path(hf_hub_download(REPO,OLD+'/'+f,revision=REV))
+  assert hashlib.sha256(path.read_bytes()).hexdigest()==sums[f]
+  with np.load(path) as z:
+   assert z['indices'].tolist()==ids[start:start+len(z['indices'])]
+   cache[start:start+len(z['target'])]=z['target']
+ fresh=pq.read_table(hf_hub_download('detection-datasets/coco','default/val/0001.parquet',repo_type='dataset',revision='26ddc382fe75dfc2a0655b5977e296ea10efebce'),columns=['image'])
+ hashes={hashlib.sha256(table['image'][int(i)].as_py()['bytes']).digest() for i in ids}
+ freshids=[]
+ for i in np.random.default_rng(SEED).permutation(len(fresh)):
+  if hashlib.sha256(fresh['image'][int(i)].as_py()['bytes']).digest() not in hashes:freshids.append(int(i))
+  if len(freshids)==160:break
+ write('manifest.json',{'train':ids,'development':freshids[:80],'heldout':freshids[80:],'fresh_file':'default/val/0001.parquet','revision':'26ddc382fe75dfc2a0655b5977e296ea10efebce','prior_model_revision':REV,'upstream_pretraining_overlap_unknown':True,'near_duplicates_not_excluded':True})
+ DURABLE.sync('data cache verified and split fixed')
+ m=load_semantic('/work/initial',DEVICE)
+ write('initial_validation.json',ev.evaluate(m,table,manifest['validation']))
+ review(m,fresh,freshids[:80],'initial_development')
+ review(m,fresh,freshids[80:],'initial_heldout')
+ write('initial_heldout_reference_metrics.json',ev.evaluate(m,fresh,freshids[80:]))
+ del m
+ arms=[('teacher_clean','teacher',False),('set_clean','set',False),('teacher_archive','teacher',True),('set_archive','set',True)]
+ for name,mode,archive in arms:
+  torch.manual_seed(SEED);np.random.seed(SEED);random.seed(SEED)
+  m=load_semantic('/work/initial',DEVICE)
+  opt=torch.optim.AdamW([{'params':m.encoder.parameters(),'lr':5e-6},{'params':[p for n,p in m.named_parameters() if not n.startswith('encoder.')],'lr':5e-5}],weight_decay=.01)
+  sched=torch.optim.lr_scheduler.LambdaLR(opt,lambda step:min((step+1)/100,1)*(.2+.8*(1+math.cos(math.pi*min(step,STEPS)/STEPS))/2))
+  ds=Photos(table,ids,cache,archive)
+  loader=DataLoader(ds,batch_size=32,shuffle=True,num_workers=4,pin_memory=True,generator=torch.Generator().manual_seed(SEED))
+  it=iter(loader);history=[];choices=0;seen=0
+  for step in range(1,STEPS+1):
+   deadline();m.train()
+   for layer in m.encoder.modules():
+    if isinstance(layer,torch.nn.BatchNorm2d):layer.eval()
+   try:L,t,o=next(it)
+   except StopIteration:ds.epoch+=1;it=iter(loader);L,t,o=next(it)
+   L,t,o=L.to(DEVICE),t.to(DEVICE),o.to(DEVICE);opt.zero_grad(set_to_none=True)
+   with torch.autocast('cuda',dtype=torch.bfloat16):p=m(L)
+   loss,choice=select_loss(p,t,o,mode)
+   assert torch.isfinite(loss)
+   loss.backward();torch.nn.utils.clip_grad_norm_(m.parameters(),1,error_if_nonfinite=True);opt.step();sched.step()
+   choices+=int(choice.sum());seen+=len(L)
+   if step%100==0:
+    history.append({'step':step,'loss':float(loss),'original_choice_fraction':choices/seen})
+    print('STEP',name,step,round(float(loss),4),flush=True)
+   if step%500==0:
+    path=OUT/name/f'step_{step:05d}';save_semantic(m,path)
+    torch.save({'optimizer':opt.state_dict(),'scheduler':sched.state_dict(),'step':step,'epoch':ds.epoch,'torch_rng':torch.get_rng_state(),'cuda_rng':torch.cuda.get_rng_state_all(),'numpy_rng':np.random.get_state(),'python_rng':random.getstate()},path/'training_state.pt')
+    write(name+'/history.json',history);write('status.json',{'status':'training','arm':name,'step':step,'elapsed_seconds':time.monotonic()-START})
+    DURABLE.sync(name+' checkpoint '+str(step))
+  write(name+'_validation.json',ev.evaluate(m,table,manifest['validation']))
+  review(m,fresh,freshids[:80],name+'_development')
+  review(m,fresh,freshids[80:],name+'_heldout')
+  write(name+'_heldout_reference_metrics.json',ev.evaluate(m,fresh,freshids[80:]))
+  ev.probes(m,name)
+  DURABLE.sync(name+' complete diagnostics')
+  del m,opt,sched,it,loader;torch.cuda.empty_cache()
+ models={'round6':load_semantic('/work/initial',DEVICE)}
+ for name,_,_ in arms:models[name]=load_semantic(OUT/name/f'step_{STEPS:05d}',DEVICE)
+ grid(models,fresh,freshids[:80],'blinded_development')
+ grid(models,fresh,freshids[80:],'blinded_heldout')
+ # Familiar historical development probes; never claim these are a held-out archival benchmark.
+ import requests
+ sources={'migrant_mother':'https://cdn.loc.gov/service/pnp/ppmsca/50200/50236v.jpg','power_house_mechanic':'https://www.archives.gov/exhibits/picturing_the_century/images/port_hine_022_v36.jpg'}
+ for name,url in sources.items():
+  try:
+   response=requests.get(url,timeout=45);response.raise_for_status()
+   im=Image.open(io.BytesIO(response.content)).convert('RGB')
+   tb=pa.table({'image':[{'bytes':response.content,'path':None}]})
+   grid(models,tb,[0],name)
+   write(name+'_source.json',{'url':url,'sha256':hashlib.sha256(response.content).hexdigest(),'use':'previously seen archival development probe; original colors unknown'})
+  except Exception as e:write(name+'_error.json',{'type':type(e).__name__,'message':str(e)})
+ write('status.json',{'status':'completed','elapsed_seconds':time.monotonic()-START,'production_approved':False,'next':'Review blinded grids for coherent plausible color and gray/sepia collapse. This pilot does not test a stochastic conditioned decoder.'})
+ DURABLE.sync('round7 four-arm experiment completed')
+if __name__=='__main__':
+ try:main()
+ except BaseException as e:
+  write('failure.json',{'type':type(e).__name__,'traceback':traceback.format_exc().replace(os.environ.get('HF_TOKEN','__EMPTY__'),'[REDACTED]')})
+  if DURABLE:DURABLE.sync('round7 failure report and latest saved checkpoints')
+  raise

experiments/decision-20260928-v2/source/semantic_model.py

@@ -0,0 +1,94 @@
+"""Compact pretrained semantic colorizer; dense and shared-palette variants."""
+import json
+from pathlib import Path
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torchvision.models import mobilenet_v3_large, MobileNet_V3_Large_Weights
+from safetensors.torch import save_file, load_file
+
+class QueryBlock(nn.Module):
+    def __init__(self,d=96):
+        super().__init__()
+        self.self_attn=nn.MultiheadAttention(d,4,batch_first=True,dropout=0)
+        self.cross_attn=nn.MultiheadAttention(d,4,batch_first=True,dropout=0)
+        self.norms=nn.ModuleList([nn.LayerNorm(d) for _ in range(3)])
+        self.ff=nn.Sequential(nn.Linear(d,2*d),nn.GELU(),nn.Linear(2*d,d))
+    def forward(self,q,memory):
+        x=self.norms[0](q);q=q+self.self_attn(x,x,x,need_weights=False)[0]
+        x=self.norms[1](q);q=q+self.cross_attn(x,memory,memory,need_weights=False)[0]
+        return q+self.ff(self.norms[2](q))
+
+def refine(d):
+    return nn.Sequential(nn.Conv2d(d,d,3,padding=1,bias=False),nn.GroupNorm(8,d),nn.SiLU())
+
+class SemanticColorizer(nn.Module):
+    def __init__(self,head='palette',pretrained=False,width=128,queries=16):
+        super().__init__()
+        if head not in ['palette','dense']:raise ValueError(head)
+        self.config={'architecture':'SemanticColorizer','head':head,'width':width,'queries':queries,'format_version':1}
+        self.encoder=mobilenet_v3_large(weights=MobileNet_V3_Large_Weights.IMAGENET1K_V2 if pretrained else None,progress=False).features
+        self.lateral=nn.ModuleList([nn.Conv2d(c,width,1) for c in [24,40,112,960]])
+        self.refine=nn.ModuleList([refine(width) for _ in range(3)])
+        self.register_buffer('rgb_mean',torch.tensor([.485,.456,.406]).view(1,3,1,1))
+        self.register_buffer('rgb_std',torch.tensor([.229,.224,.225]).view(1,3,1,1))
+        if head=='palette':
+            self.queries=nn.Parameter(torch.randn(queries,width)*.2)
+            self.query_blocks=nn.ModuleList([QueryBlock(width) for _ in range(2)])
+            self.memory_norm=nn.LayerNorm(width)
+            self.query_norm=nn.LayerNorm(width)
+            self.pixel=nn.Conv2d(width,width,1)
+            self.palette=nn.Sequential(nn.Linear(width,width),nn.GELU(),nn.Linear(width,2))
+            self.residual=nn.Conv2d(width,2,1)
+            nn.init.normal_(self.palette[-1].weight,std=.01);nn.init.zeros_(self.palette[-1].bias)
+            nn.init.zeros_(self.residual.weight);nn.init.zeros_(self.residual.bias)
+        else:
+            self.dense=nn.Sequential(refine(width),nn.Conv2d(width,2,1))
+            nn.init.normal_(self.dense[-1].weight,std=.01);nn.init.zeros_(self.dense[-1].bias)
+        count=sum(p.numel() for p in self.parameters())
+        if count>=4_000_000:raise ValueError(f'Parameter budget exceeded: {count}')
+
+    @staticmethod
+    def neutral_rgb(L):
+        light=(L.float()*50+50).clamp(0,100)
+        y=torch.where(light>8,((light+16)/116)**3,light/903.296296)
+        g=torch.where(y<=.0031308,12.92*y,1.055*y.clamp_min(1e-8).pow(1/2.4)-.055)
+        return g.expand(-1,3,-1,-1)
+
+    def forward(self,L):
+        h,w=L.shape[-2:]
+        x=F.pad(self.neutral_rgb(L),(0,(-w)%32,0,(-h)%32),mode='replicate')
+        x=(x-self.rgb_mean)/self.rgb_std
+        features=[]
+        for i,layer in enumerate(self.encoder):
+            x=layer(x)
+            if i in [3,6,12,16]:features.append(x)
+        projected=[layer(f) for layer,f in zip(self.lateral,features)]
+        x=projected[-1]
+        for i in range(2,-1,-1):
+            x=self.refine[2-i](F.interpolate(x,size=projected[i].shape[-2:],mode='bilinear',align_corners=False)+projected[i])
+        if self.config['head']=='palette':
+            memory=torch.cat([F.adaptive_avg_pool2d(f,(8,8)).flatten(2).transpose(1,2) for f in projected[1:]],1)
+            memory=self.memory_norm(memory)
+            q=self.queries[None].expand(L.shape[0],-1,-1)
+            for block in self.query_blocks:q=block(q,memory)
+            q=self.query_norm(q)
+            palette=80*torch.tanh(self.palette(q))
+            masks=torch.einsum('bqd,bdhw->bqhw',q,self.pixel(x))/(self.config['width']**.5)
+            weights=F.softmax(masks.float(),dim=1)
+            ab=torch.einsum('bqhw,bqc->bchw',weights,palette.float())+2*torch.tanh(self.residual(x).float())
+        else:ab=80*torch.tanh(self.dense(x).float())
+        return F.interpolate(ab,size=(x.shape[-2]*4,x.shape[-1]*4),mode='bilinear',align_corners=False)[...,:h,:w]
+    def decode(self,z,temperature=.38):return z.float()
+
+def save_semantic(model,path):
+    path=Path(path);path.mkdir(parents=True,exist_ok=True)
+    save_file({k:v.detach().cpu().contiguous() for k,v in model.state_dict().items()},str(path/'model.safetensors'))
+    (path/'config.json').write_text(json.dumps(model.config,indent=2))
+    (path/'README.md').write_text('# Experimental semantic colorizer\n\nHead: '+model.config['head']+'. Parameters: '+str(sum(p.numel() for p in model.parameters()))+'.\n\nNot approved for production. Requires semantic_model.py; incompatible with the old U-Net loader. Input is Lab lightness normalized to [-1,1]; output is Lab ab. See the run protocol, provenance, selection and visual comparisons. Predictions are plausible colors, not recovered historical truth.\n')
+
+def load_semantic(path,device='cpu'):
+    path=Path(path);cfg=json.loads((path/'config.json').read_text())
+    model=SemanticColorizer(**{k:cfg[k] for k in ['head','width','queries']})
+    model.load_state_dict(load_file(str(path/'model.safetensors')),strict=True)
+    return model.to(device).eval()

experiments/decision-20260928-v2/source/spatial.py

@@ -0,0 +1,34 @@
+"""Controlled spatial decoding alternatives; no learned parameters."""
+import math
+import torch
+import torch.nn.functional as F
+
+def box_mean(x,radius):
+    # Border-normalized local windows, also work on images smaller than kernel.
+    return F.avg_pool2d(x,2*radius+1,stride=1,padding=radius,count_include_pad=False)
+
+def guided_chroma(L,ab,radius=4,epsilon=.001):
+    """Scalar luminance-guided local linear filter (He et al., ECCV 2010).
+
+    L is the network's [-1,1] luminance. Epsilon is in [0,1] luminance units.
+    Uses luminance only; reference colors never enter inference.
+    """
+    if not isinstance(radius,int) or radius<0 or not math.isfinite(epsilon) or epsilon<=0:
+        raise ValueError('Invalid guided-filter radius or epsilon')
+    if radius==0:return ab
+    I=(L.float()+1)/2;p=ab.float()
+    mi=box_mean(I,radius);mp=box_mean(p,radius)
+    var=(box_mean(I*I,radius)-mi*mi).clamp_min(0)
+    cov=box_mean(I*p,radius)-mi*mp
+    a=cov/(var+epsilon);b=mp-a*mi
+    return box_mean(a,radius)*I+box_mean(b,radius)
+
+def spatial_decode(model,logits,L,temperature=.38,pool=1,radius=0,epsilon=.001):
+    if pool<1 or not isinstance(pool,int):raise ValueError('pool must be a positive integer')
+    if pool>1:
+        # Average evidence before annealing, then upsample chroma, not RGB.
+        small=F.avg_pool2d(logits,pool,ceil_mode=True,count_include_pad=False)
+        ab=model.decode(small,temperature)
+        ab=F.interpolate(ab,size=L.shape[-2:],mode='bilinear',align_corners=False)
+    else:ab=model.decode(logits,temperature)
+    return guided_chroma(L,ab,radius,epsilon)

experiments/decision-20260928-v2/source/train_suite.py

@@ -0,0 +1,359 @@
+"""Budget-bounded architecture/curriculum screening. Sources pinned by bootstrap."""
+import os,sys,json,time,math,random,hashlib,shutil,traceback,copy,io
+from pathlib import Path
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from PIL import Image,ImageDraw
+from skimage.color import rgb2lab
+import cv2,pyarrow as pa,pyarrow.parquet as pq
+from huggingface_hub import HfApi,hf_hub_download
+from safetensors.torch import load_file
+from semantic_model import load_semantic
+from decision_model import DecisionColorizer,initialize_from_v3,save_decision,load_decision
+import persistence
+import r7 as r
+from data import decode_image
+
+REPO='User-2468/mini-unet-colorizer'
+BASE='1a9eb8af2754ad2329a24cfe50d388cb559441d0'
+ARTIFACTS='26d731862cc0ea531e7198fa823cb09db25bd243'
+CACHE_REV='7b10485ee9d205ce2f7b660dfc6a90012d78b1cb'
+COCO_REV='26ddc382fe75dfc2a0655b5977e296ea10efebce'
+PREFIX=os.environ.get('EXPERIMENT_PREFIX','experiments/decision-20260928')
+SEED=int(os.environ.get('SEED','92893'))
+STEPS=int(os.environ.get('STEPS','3000'));BATCH=24
+START=time.monotonic();TRAIN_LIMIT=float(os.environ.get('TRAIN_LIMIT_SECONDS','3000'))
+OUT=Path('/work/results');OUT.mkdir(exist_ok=True,parents=True)
+persistence.PREFIX=PREFIX;r.OUT=OUT;r.ev.OUT=OUT;r.DEVICE='cuda';r.ev.DEVICE='cuda';r.ev.deadline=lambda:None
+api=HfApi();DURABLE=None
+def write(n,obj):
+    p=OUT/n;p.parent.mkdir(parents=True,exist_ok=True);p.write_text(json.dumps(obj,indent=2));return obj
+def dl(f,rev=ARTIFACTS):return Path(hf_hub_download(REPO,f,revision=rev))
+def seed(s):torch.manual_seed(s);np.random.seed(s);random.seed(s)
+
+def objective(details,target,step):
+    allout=details['all'];b,k=allout.shape[:2]
+    losses=r.losses(allout.flatten(0,1),target[:,None].expand(-1,k,-1,-1,-1).flatten(0,1)).reshape(b,k)
+    if k==1:return losses.mean(),losses.argmin(1),losses
+    # One winning complete image, never a per-pixel best-of-K patchwork.
+    winner=losses.detach().argmin(1)
+    selected=losses.gather(1,winner[:,None]).mean()
+    # Small nonwinner term prevents completely untrained branches; no saturation reward.
+    loss=.95*selected+.05*losses.mean()+.1*F.cross_entropy(details['scores'],winner)
+    return loss,winner,losses
+
+class Batches:
+    def __init__(self,rgb,teacher):
+        self.rgb=torch.from_numpy(rgb).cuda().permute(0,3,1,2)
+        self.teacher=torch.from_numpy(teacher).cuda().float()
+        self.n=len(rgb)
+    @staticmethod
+    def light(g):
+        y=torch.where(g<=.04045,g/12.92,((g+.055)/1.055).pow(2.4))
+        l=torch.where(y>.008856,116*y.clamp_min(1e-9).pow(1/3)-16,903.296296*y)
+        return l/50-1
+    def batch(self,step,recipe,original,curriculum_step=None):
+        phase=step if curriculum_step is None else curriculum_step
+        gen=torch.Generator(device='cuda').manual_seed(SEED*100000+step)
+        ids=torch.randint(self.n,(BATCH,),generator=gen,device='cuda')
+        rgb=self.rgb[ids].float()/255;t=self.teacher[ids];o=original[ids]
+        g=(rgb*rgb.new_tensor([.299,.587,.114])[None,:,None,None]).sum(1,keepdim=True)
+        # Emulate standard 8-bit PIL grayscale conversion before Lab conversion.
+        g=(g*255).round()/255
+        L=self.light(g)
+        if recipe=='staged' and phase>STEPS*2/3:
+            take=torch.rand(BATCH,1,1,1,generator=gen,device='cuda')<.35
+            weights=torch.rand(BATCH,3,1,1,generator=gen,device='cuda')+rgb.new_tensor([.8,1.2,.2])[None,:,None,None]
+            weights/=weights.sum(1,keepdim=True)
+            film=(rgb*weights).sum(1,keepdim=True)
+            gamma=.85+.4*torch.rand(BATCH,1,1,1,generator=gen,device='cuda')
+            film=(film.pow(gamma)-.5)*(.8+.3*torch.rand(BATCH,1,1,1,generator=gen,device='cuda'))+.5
+            film=film+.005*torch.randn(film.shape,generator=gen,device='cuda')
+            L=torch.where(take,self.light(film.clamp(0,1)),L)
+        else:
+            gain=.9+.2*torch.rand(BATCH,1,1,1,generator=gen,device='cuda')
+            L=(L*gain).clamp(-1,1)
+        flips=torch.rand(BATCH,1,1,1,generator=gen,device='cuda')<.5
+        L=torch.where(flips,L.flip(-1),L);t=torch.where(flips,t.flip(-1),t);o=torch.where(flips,o.flip(-1),o)
+        prob=0 if recipe=='teacher' else .5
+        if recipe=='staged':prob*=min(max((phase/STEPS-.15)/.35,0),1)
+        pick=torch.rand(BATCH,1,1,1,generator=gen,device='cuda')<prob
+        # Stochastic full targets: never choose the easier one, never average hues.
+        target=torch.where(pick,o,t)
+        return L,target,ids,float(pick.float().mean())
+
+def summary(result):return {s:result[s]['summary'] for s in ['gray','film']}
+def score(result,baseline):
+    val=0;okay=True
+    for style in ['gray','film']:
+        s=result[style]['summary'];b=baseline[style]['summary']
+        okay &= s['missed_color']<=b['missed_color']+.015 and s['neutral_spill']<=b['neutral_spill']+.015 and s['color_coverage']>=.95*b['color_coverage'] and s['ab_error']<=b['ab_error']*1.10
+        val+=s['patch_excess']/max(b['patch_excess'],1e-6)+.2*s['ab_error']/b['ab_error']+2*s['missed_color']+s['neutral_spill']
+    return val/2,bool(okay)
+
+@torch.inference_mode()
+def diagnostics(model,table,ids):
+    model.eval();rows=[]
+    for idx in ids:
+        L,t,_=r.ev.gray_arrays(decode_image(table,idx));x=torch.from_numpy(L)[None].cuda()
+        v=model(x,True);a=v['all'];sel=int(v['scores'].argmax(1))
+        resized=model(F.interpolate(x,(224,224),mode='bilinear',align_corners=False),True)
+        p=F.interpolate(resized['output'],(256,256),mode='bilinear',align_corners=False)
+        flip=model(x.flip(-1),True)
+        colors=a[0].mean((-1,-2));k=model.modes
+        diff=(a[:,:,None]-a[:,None]).abs().mean((0,3,4,5))
+        target=torch.from_numpy(t)[None].cuda();target64=F.avg_pool2d(target,4)
+        losses=r.losses(a.flatten(0,1),target64.expand(k,-1,-1,-1))
+        mask=v['weights'].clamp_min(1e-8)
+        rows.append({'index':int(idx),'selected_mode':sel,'resized_mode':int(resized['scores'].argmax(1)),
+            'flip_mode':int(flip['scores'].argmax(1)),'resize_ab_change':float((p-v['output']).abs().mean()),
+            'flip_ab_change':float((flip['output'].flip(-1)-v['output']).abs().mean()),
+            'mode_diversity':float(diff.sum()/max(k*(k-1),1)),
+            'default_target_loss':float(losses[sel]),'oracle_target_loss':float(losses.min()),
+            'mask_entropy':float(-(mask*mask.log()).sum(1).mean()),
+            'palette_chroma':float(v['palette'].norm(dim=-1).mean()),'output_chroma':float(v['output'].norm(dim=1).mean())})
+    keys=['resize_ab_change','flip_ab_change','mode_diversity','default_target_loss','oracle_target_loss','mask_entropy','palette_chroma','output_chroma']
+    return {'rows':rows,'summary':{k:float(np.mean([x[k] for x in rows])) for k in keys},
+        'mode_frequency':np.bincount([x['selected_mode'] for x in rows],minlength=model.modes).tolist(),
+        'resize_switch_fraction':float(np.mean([x['selected_mode']!=x['resized_mode'] for x in rows])),
+        'note':'Oracle uses unknown original only for diagnosis. Default mode is selected by the learned image-only score, never by ground truth.'}
+
+def paired_bootstrap(result,base):
+    rng=np.random.default_rng(937);out={}
+    for style in ['gray','film']:
+        br={z['index']:z for z in base[style]['per_image']};rows=[z for z in result[style]['per_image'] if z['target_chroma']>=5]
+        out[style]={}
+        for key in ['patch_excess','raw_patch_excess','missed_color','neutral_spill','color_coverage','ab_error']:
+            d=np.array([z[key]-br[z['index']][key] for z in rows]);boot=d[rng.integers(len(d),size=(3000,len(d)))].mean(1)
+            out[style][key]={'delta':float(d.mean()),'ci95':np.quantile(boot,[.025,.975]).tolist()}
+    return out
+
+@torch.inference_mode()
+def pipeline_grid(models,table,ids,label):
+    from inference import colorize
+    from PIL import ImageOps
+    names=list(models);order=np.random.default_rng(9184).permutation(len(names))
+    key={chr(65+j):names[int(i)] for j,i in enumerate(order)};write(label+'_key.json',key)
+    for start in range(0,min(32,len(ids)),4):
+        canvas=Image.new('RGB',(320*(len(names)+1),344*len(ids[start:start+4])),'white');d=ImageDraw.Draw(canvas)
+        for row,idx in enumerate(ids[start:start+4]):
+            original=decode_image(table,idx).convert('L').convert('RGB')
+            original.thumbnail((800,800))
+            d.text((2,row*344),f'{idx}: grayscale | '+' | '.join(key),fill='black')
+            canvas.paste(ImageOps.pad(original,(320,320),color='white'),(0,row*344+24))
+            for col,j in enumerate(order):
+                output=colorize(models[names[int(j)]].eval(),original,size=256,radius=8)
+                canvas.paste(ImageOps.pad(output,(320,320),color='white'),((col+1)*320,row*344+24))
+        canvas.save(OUT/f'{label}_{start//4}.jpg',quality=93)
+
+@torch.inference_mode()
+def resolution_grid(model,table,records):
+    from inference import colorize
+    from PIL import ImageOps
+    for start in range(0,len(table),3):
+        count=min(3,len(table)-start)
+        canvas=Image.new('RGB',(1280,344*count),'white');d=ImageDraw.Draw(canvas)
+        for row,idx in enumerate(range(start,start+count)):
+            im=decode_image(table,idx).convert('L').convert('RGB');im.thumbnail((1000,1000))
+            d.text((2,row*344),records[idx]['name']+' | input | 256 | 384 | 512',fill='black')
+            canvas.paste(ImageOps.pad(im,(320,320),color='white'),(0,row*344+24))
+            for col,size in enumerate([256,384,512],1):
+                pred=colorize(model,im,size=size,radius=8)
+                canvas.paste(ImageOps.pad(pred,(320,320),color='white'),(col*320,row*344+24))
+        canvas.save(OUT/f'v3_resolution_{start//3}.jpg',quality=94)
+
+def main():
+    global DURABLE
+    assert api.whoami()['name']=='User-2468'
+    DURABLE=persistence.DurableRun(OUT)
+    shutil.copytree('/work/source',OUT/'source',dirs_exist_ok=True,ignore=shutil.ignore_patterns('__pycache__'))
+    shutil.copy2('/work/PROTOCOL.md',OUT/'PROTOCOL.md')
+    if Path('/work/REVIEW_HANDOFF.md').exists():shutil.copy2('/work/REVIEW_HANDOFF.md',OUT/'REVIEW_HANDOFF.md')
+    if Path('/work/supplement').exists():shutil.copytree('/work/supplement',OUT/'supplement',dirs_exist_ok=True)
+    write('status.json',{'status':'preflight','seed':SEED,'production_approved':False})
+    DURABLE.sync('source and write verification before training')
+    torch.set_num_threads(6);seed(SEED)
+    torch.backends.cuda.matmul.allow_tf32=False;torch.backends.cudnn.allow_tf32=False
+    initial=Path('/work/initial');initial.mkdir(exist_ok=True)
+    for f in ['model.safetensors','config.json']:shutil.copy2(dl(f,BASE),initial/f)
+    baseline=load_semantic(initial,'cuda').requires_grad_(False)
+    counts={};smokes={}
+    encoder_rev=api.model_info('timm/mobilevitv2_075.cvnets_in1k').sha
+    write('encoder_provenance.json',{'repo':'timm/mobilevitv2_075.cvnets_in1k','revision':encoder_rev,'license':'Apple sample code license; include upstream LICENSE if deployed','timm':'1.0.19'})
+    constructors=[('single',1,'mobilenet'),('multi',4,'mobilenet'),('mobilevit',1,'mobilevit')]
+    for name,k,backbone in constructors:
+        seed(SEED);m=DecisionColorizer(modes=k,backbone=backbone,pretrained=backbone=='mobilevit',encoder_revision=encoder_rev if backbone=='mobilevit' else None).cuda()
+        copied=initialize_from_v3(m,baseline);m.eval();count=sum(p.numel() for p in m.parameters());assert count<4_000_000
+        counts[name]=count
+        x=torch.rand(2,1,97,113,device='cuda')*2-1
+        with torch.no_grad():
+            v=m(x,True);assert v['all'].shape==(2,k,2,97,113) and torch.isfinite(v['all']).all()
+            parity=float((v['output']-baseline(x)).abs().max()) if name=='single' else None
+            if parity is not None:assert parity<1e-3,parity
+        loss,_,_=objective(m(x,True),torch.randn(2,2,64,64,device='cuda'),1)
+        loss.backward();assert torch.isfinite(loss) and all(torch.isfinite(p.grad).all() for p in m.parameters() if p.grad is not None)
+        m.zero_grad(set_to_none=True);save_decision(m,OUT/'initial'/name)
+        re=load_decision(OUT/'initial'/name,'cuda')
+        with torch.no_grad():assert torch.allclose(m(x),re(x),atol=1e-4)
+        smokes[name]={'parameters':count,'copied_tensors':len(copied),'odd_shape':True,'finite_backward':True,'reload':True,'baseline_max_abs':parity}
+        del m,re
+    write('smoke.json',smokes);DURABLE.sync('all three architectures pass preflight')
+    torch.backends.cuda.matmul.allow_tf32=True;torch.backends.cudnn.allow_tf32=True;torch.backends.cudnn.benchmark=True
+    tables=[]
+    for repo,rev,files in [('johnowhitaker/imagenette2-320','771c1310a2487e8076ede6b7d6307244aa8400af',['default/train/0000.parquet']),('detection-datasets/coco',COCO_REV,['default/train/0000.parquet','default/train/0001.parquet'])]:
+        for f in files:
+            print('PREP downloading',repo,f,flush=True)
+            tables.append(pq.read_table(hf_hub_download(repo,f,repo_type='dataset',revision=rev),columns=['image']))
+            print('PREP loaded',repo,f,len(tables[-1]),flush=True)
+    table=pa.concat_tables(tables)
+    full_manifest=json.loads(dl('experiments/region-coherence-20260928/source/previous_manifest.json').read_text())
+    full_ids=full_manifest['train']
+    # Same fixed training subset for every arm, independent of new dev/test.
+    ids=np.random.default_rng(92893).choice(full_ids,8192,replace=False).tolist();pos={i:j for j,i in enumerate(ids)}
+    teacher=np.empty((len(ids),2,64,64),np.float16)
+    sums=json.loads(dl('experiments/round6-20260928/SHA256SUMS.json',CACHE_REV).read_text())
+    for start in range(0,len(full_ids),2048):
+        f=f'teacher_cache/{start:05d}.npz';p=dl('experiments/round6-20260928/'+f,CACHE_REV)
+        assert hashlib.sha256(p.read_bytes()).hexdigest()==sums[f]
+        with np.load(p) as z:
+            # NpzFile indexing decompresses a member on every access. Materialize once.
+            cache_ids=z['indices'];cache_targets=z['target']
+            assert cache_ids.tolist()==full_ids[start:start+len(cache_ids)]
+            src=[j for j,i in enumerate(cache_ids) if int(i) in pos]
+            dst=[pos[int(cache_ids[j])] for j in src]
+            teacher[dst]=cache_targets[src]
+            print('PREP cache',start,'selected',len(src),flush=True)
+    print('PREP decoding training images',len(ids),flush=True)
+    rgb=np.stack([np.asarray(decode_image(table,i).resize((256,256),Image.Resampling.BILINEAR)) for i in ids])
+    original=np.stack([cv2.resize(rgb2lab(im.astype(np.float32)/255)[...,1:],(64,64),interpolation=cv2.INTER_AREA).transpose(2,0,1) for im in rgb]).astype(np.float32)
+    batcher=Batches(rgb,teacher);original=torch.from_numpy(original).cuda();del rgb,teacher
+    print('PREP training tensors ready',flush=True)
+    fresh=pq.read_table(hf_hub_download('detection-datasets/coco','default/val/0001.parquet',repo_type='dataset',revision=COCO_REV),columns=['image'])
+    exclude=set()
+    for path,keys in [('round7-20260928',['development','heldout']),('region-coherence-20260928',['development_regression','heldout_regression','new_holdout']),('recurrent-refinement-20260928',['fresh_holdout','development_regression'])]:
+        manifest=json.loads(dl('experiments/'+path+'/manifest.json').read_text())
+        for key in keys:exclude.update(manifest[key])
+    hashes={hashlib.sha256(table['image'][i].as_py()['bytes']).digest() for i in full_ids}
+    freshids=[int(i) for i in np.random.default_rng(92893).permutation(len(fresh)) if int(i) not in exclude and hashlib.sha256(fresh['image'][int(i)].as_py()['bytes']).digest() not in hashes][:288]
+    assert len(freshids)==288
+    dev,test=freshids[:128],freshids[128:]
+    write('manifest.json',{'train':ids,'development':dev,'test':test,'prior_eval_excluded':sorted(exclude),'coco_revision':COCO_REV,'fresh_file':'default/val/0001.parquet','teacher_revision':CACHE_REV,'base_revision':BASE,'seed':SEED,'near_duplicates_and_upstream_overlap_not_excluded':True})
+    base_dev=r.ev.evaluate(baseline,fresh,dev);write('baseline_development.json',base_dev)
+    DURABLE.sync('dataset checks and unseen development/test split frozen')
+    arms=[(h,c) for h in ['single','multi'] for c in ['teacher','mix','staged']]+[('mobilevit','staged')]
+    if os.environ.get('ARMS'):arms=[tuple(x.split(':')) for x in os.environ['ARMS'].split(',')]
+    selected={};histories={};dev_results={};begin_train=time.monotonic()
+    for head,recipe in arms:
+        name=head+'_'+recipe;seed(SEED)
+        m=load_decision(OUT/'initial'/head,'cuda')
+        # New encoder gets a separate alignment warmup, explicitly outside matched six arms.
+        warmup=1000 if head=='mobilevit' else 0
+        groups=[{'params':[p for n,p in m.named_parameters() if n.startswith('encoder.')],'lr':2e-5 if head=='mobilevit' else 1e-5},
+                {'params':[p for n,p in m.named_parameters() if not n.startswith('encoder.')],'lr':2e-4 if head=='mobilevit' else 1e-4}]
+        opt=torch.optim.AdamW(groups,weight_decay=.01)
+        for g in opt.param_groups:g['base_lr']=g['lr']
+        history=[];best=1e9;beststep=0;last=0;arm_start=time.monotonic();mode_counts=np.zeros(m.modes,np.int64)
+        for s in range(1,STEPS+warmup+1):
+            if time.monotonic()-START>TRAIN_LIMIT:break
+            step=max(1,s-warmup);active_recipe='teacher' if s<=warmup else recipe
+            L,target,_,fraction=batcher.batch(s,active_recipe,original,curriculum_step=step)
+            m.train()
+            for layer in m.encoder.modules():
+                if isinstance(layer,nn.BatchNorm2d):layer.eval()
+            opt.zero_grad(set_to_none=True)
+            factor=min(s/150,1)*(.15+.85*(1+math.cos(math.pi*max(0,s-warmup)/STEPS))/2)
+            for g in opt.param_groups:g['lr']=g['base_lr']*factor
+            with torch.autocast('cuda',dtype=torch.bfloat16):
+                details=m(L,True)
+                loss,winners,terms=objective(details,target,step)
+                consistency=loss.new_zeros(())
+                if active_recipe=='staged' and step>STEPS*2/3 and s%4==0:
+                    small=m(F.interpolate(L,(192,192),mode='bilinear',align_corners=False),True)
+                    a=F.adaptive_avg_pool2d(small['all'].flatten(0,1).float(),(64,64))
+                    b=F.adaptive_avg_pool2d(details['all'].flatten(0,1).detach().float(),(64,64))
+                    consistency=F.l1_loss(a/20,b/20)
+                    if m.modes>1:consistency+=.1*F.kl_div(small['scores'].log_softmax(1),details['scores'].detach().softmax(1),reduction='batchmean')
+                    loss=loss+.4*consistency # every fourth step -> mean weight .1
+            assert torch.isfinite(loss),name
+            loss.backward();torch.nn.utils.clip_grad_norm_(m.parameters(),1,error_if_nonfinite=True);opt.step();last=s
+            mode_counts+=np.bincount(winners.detach().cpu().numpy(),minlength=m.modes)
+            if s%100==0:
+                row={'step':s,'loss':float(loss.detach()),'reconstruction':float(terms.mean().detach()),'consistency':float(consistency.detach()),'photo_fraction_this_batch':fraction,'winner_counts':mode_counts.tolist(),'seconds':time.monotonic()-arm_start}
+                history.append(row);print('STEP',name,s,round(row['loss'],4),flush=True)
+            if s%1000==0 or s==STEPS+warmup:
+                m.eval();res=r.ev.evaluate(m,fresh,dev);val,okay=score(res,base_dev)
+                write(name+f'/development_{s:05d}.json',res)
+                write(name+'/history.json',history)
+                save_decision(m,OUT/name/f'step_{s:05d}')
+                # Ineligible models still retained for diagnosis, ranked after eligible.
+                ranked=val+(0 if okay else 100)
+                if ranked<best:
+                    best=ranked;beststep=s;save_decision(m,OUT/name/'candidate');dev_results[name]=res
+                write('status.json',{'status':'training','arm':name,'step':s,'elapsed_seconds':time.monotonic()-START,'production_approved':False})
+                DURABLE.sync(name+' checkpoint '+str(s))
+        if not beststep:raise RuntimeError('Budget exhausted before first candidate for '+name)
+        write(name+'/history.json',history)
+        torch.save({'optimizer':opt.state_dict(),'step':last,'seed':SEED,'torch_rng':torch.get_rng_state(),'cuda_rng':torch.cuda.get_rng_state_all(),'exact_resume':False},OUT/name/'optimizer.pt')
+        selected[name]={'step':beststep,'rank_score':best,'parameters':counts[head],'steps_completed':last,'warmup_steps':warmup,'seconds':time.monotonic()-arm_start}
+        write('candidates.json',selected);DURABLE.sync(name+' selected checkpoint on development only')
+        del m,opt;torch.cuda.empty_cache()
+        if last<STEPS+warmup:break
+    # Test is opened only after all checkpoint choices have been frozen.
+    write('candidates.json',selected);DURABLE.sync('freeze candidates before opening final test')
+    models={'v3':baseline};test_results={}
+    base_test=r.ev.evaluate(baseline,fresh,test);write('v3_test.json',base_test);test_results['v3']=base_test
+    for name in selected:
+        m=load_decision(OUT/name/'candidate','cuda');models[name]=m
+        res=r.ev.evaluate(m,fresh,test);test_results[name]=res
+        write(name+'_test.json',res);write(name+'_test_paired.json',paired_bootstrap(res,base_test))
+        write(name+'_diagnostics.json',diagnostics(m,fresh,test[:48]))
+        r.ev.probes(m,name+'_probes')
+        x=torch.zeros(1,1,256,256,device='cuda')
+        with torch.inference_mode():
+            for _ in range(5):m(x)
+            torch.cuda.synchronize();t0=time.monotonic()
+            for _ in range(30):m(x)
+            torch.cuda.synchronize()
+        write(name+'_latency.json',{'milliseconds':1000*(time.monotonic()-t0)/30,'hardware':torch.cuda.get_device_name(),'size':256,'precision':'FP32'})
+        DURABLE.sync(name+' final test and diagnostic outputs')
+    r.ev.probes(baseline,'v3_probes')
+    # Smaller comparison groups preserve enough image detail to inspect.
+    for head in ['single','multi']:
+        group={n:m for n,m in models.items() if n=='v3' or n.startswith(head+'_')}
+        r.grid(group,fresh,test,head+'_test')
+    if 'mobilevit_staged' in models:r.grid({'v3':baseline,'single_staged':models['single_staged'],'mobilevit_staged':models['mobilevit_staged']},fresh,test,'encoder_test')
+    # Historical originals deliberately never serve as neutral-color supervision.
+    archive=json.loads(Path('/work/archive_sources.json').read_text())
+    import requests
+    records=[];images=[]
+    for entry in archive:
+        try:
+            response=requests.get(entry['image_url'],timeout=20);response.raise_for_status()
+            im=Image.open(io.BytesIO(response.content)).convert('RGB');im.load()
+            images.append({'bytes':response.content,'path':None});records.append(entry|{'sha256':hashlib.sha256(response.content).hexdigest()})
+        except Exception as e:records.append(entry|{'failed':type(e).__name__})
+    if images:
+        ar=pa.table({'image':images})
+        resolution_grid(baseline,ar,[x for x in records if 'failed' not in x])
+        for head in ['single','multi']:
+            r.grid({n:m for n,m in models.items() if n=='v3' or n.startswith(head+'_')},ar,list(range(len(images))),head+'_archive')
+        if 'mobilevit_staged' in models:r.grid({'v3':baseline,'mobilevit_staged':models['mobilevit_staged']},ar,list(range(len(images))),'encoder_archive')
+        pipeline_grid({'v3':baseline,**{n:m for n,m in models.items() if n.endswith('staged')}},ar,list(range(len(images))),'production_archive')
+    pipeline_grid({'v3':baseline,**{n:m for n,m in models.items() if n.endswith('staged')}},fresh,test[:16],'production_test')
+    write('archive_sources.json',records)
+    write('summary.json',{'parameters':counts,'candidates':selected,'test':{n:summary(v) for n,v in test_results.items()},'all_arms_completed':len(selected)==len(arms),'elapsed_seconds':time.monotonic()-START,'estimated_compute_usd':(time.monotonic()-START)/3600*.8,'warning':'No metric proves realism. All outputs need visual review. MobileViT received extra alignment warmup and different encoder LR; not a pure head ablation.'})
+    write('status.json',{'status':'completed','all_arms_completed':len(selected)==len(arms),'elapsed_seconds':time.monotonic()-START,'production_approved':False})
+    DURABLE.sync('architecture and curriculum suite completed')
+
+if __name__=='__main__':
+    try:main()
+    except BaseException:
+        msg=traceback.format_exc();token=os.environ.get('HF_TOKEN')
+        if token:msg=msg.replace(token,'[REDACTED]')
+        write('failure.json',{'traceback':msg});write('status.json',{'status':'failed','elapsed_seconds':time.monotonic()-START,'production_approved':False})
+        if DURABLE:
+            try:DURABLE.sync('failure report and saved checkpoints')
+            except Exception:pass
+        print(msg,flush=True);raise SystemExit(1)

experiments/decision-20260928-v2/status.json

@@ -0,0 +1,5 @@
+{
+  "status": "preflight",
+  "seed": 92893,
+  "production_approved": false
+}

experiments/decision-20260928-v2/supplement/baseline_nara_resolution.json

@@ -0,0 +1,128 @@
+[
+  {
+    "name": "nara_42.jpg",
+    "size": 256,
+    "seconds_cpu": 0.14755021000019042,
+    "mask_entropy": 2.0555808544158936,
+    "output_chroma": 12.437393188476562
+  },
+  {
+    "name": "nara_42.jpg",
+    "size": 384,
+    "seconds_cpu": 0.23218034499996065,
+    "mask_entropy": 2.090886116027832,
+    "output_chroma": 14.703699111938477
+  },
+  {
+    "name": "nara_42.jpg",
+    "size": 512,
+    "seconds_cpu": 0.3470577670000239,
+    "mask_entropy": 2.164964199066162,
+    "output_chroma": 13.910662651062012
+  },
+  {
+    "name": "nara_43.jpg",
+    "size": 256,
+    "seconds_cpu": 0.11568649200034997,
+    "mask_entropy": 2.221789598464966,
+    "output_chroma": 22.151323318481445
+  },
+  {
+    "name": "nara_43.jpg",
+    "size": 384,
+    "seconds_cpu": 0.17595398799994655,
+    "mask_entropy": 2.151303291320801,
+    "output_chroma": 23.234233856201172
+  },
+  {
+    "name": "nara_43.jpg",
+    "size": 512,
+    "seconds_cpu": 0.2790908069996476,
+    "mask_entropy": 2.1258065700531006,
+    "output_chroma": 20.545372009277344
+  },
+  {
+    "name": "nara_44.jpg",
+    "size": 256,
+    "seconds_cpu": 0.09606875300005413,
+    "mask_entropy": 1.8140740394592285,
+    "output_chroma": 7.230224609375
+  },
+  {
+    "name": "nara_44.jpg",
+    "size": 384,
+    "seconds_cpu": 0.1647310340003969,
+    "mask_entropy": 1.9336862564086914,
+    "output_chroma": 8.660061836242676
+  },
+  {
+    "name": "nara_44.jpg",
+    "size": 512,
+    "seconds_cpu": 0.2678544229997897,
+    "mask_entropy": 2.003618001937866,
+    "output_chroma": 10.750614166259766
+  },
+  {
+    "name": "nara_45.jpg",
+    "size": 256,
+    "seconds_cpu": 0.12318589300002714,
+    "mask_entropy": 1.9286333322525024,
+    "output_chroma": 10.617255210876465
+  },
+  {
+    "name": "nara_45.jpg",
+    "size": 384,
+    "seconds_cpu": 0.2194160090002697,
+    "mask_entropy": 1.786165475845337,
+    "output_chroma": 13.136454582214355
+  },
+  {
+    "name": "nara_45.jpg",
+    "size": 512,
+    "seconds_cpu": 0.3068678010004078,
+    "mask_entropy": 1.711348056793213,
+    "output_chroma": 15.462327003479004
+  },
+  {
+    "name": "nara_46.jpg",
+    "size": 256,
+    "seconds_cpu": 0.14160436099973595,
+    "mask_entropy": 1.984742522239685,
+    "output_chroma": 6.706954002380371
+  },
+  {
+    "name": "nara_46.jpg",
+    "size": 384,
+    "seconds_cpu": 0.20283023299998604,
+    "mask_entropy": 2.0790905952453613,
+    "output_chroma": 8.468958854675293
+  },
+  {
+    "name": "nara_46.jpg",
+    "size": 512,
+    "seconds_cpu": 0.3308731010001793,
+    "mask_entropy": 2.1869609355926514,
+    "output_chroma": 9.939047813415527
+  },
+  {
+    "name": "nara_49.jpg",
+    "size": 256,
+    "seconds_cpu": 0.14086192399963693,
+    "mask_entropy": 2.110356330871582,
+    "output_chroma": 15.332934379577637
+  },
+  {
+    "name": "nara_49.jpg",
+    "size": 384,
+    "seconds_cpu": 0.2311230479999722,
+    "mask_entropy": 2.158229112625122,
+    "output_chroma": 19.6121768951416
+  },
+  {
+    "name": "nara_49.jpg",
+    "size": 512,
+    "seconds_cpu": 0.2948662769999828,
+    "mask_entropy": 2.1546900272369385,
+    "output_chroma": 16.430278778076172
+  }
+]

experiments/decision-20260928-v2/supplement/baseline_resolution.json

@@ -0,0 +1,23 @@
+[
+  {
+    "image": "07.jpg",
+    "size": 256,
+    "mask_entropy": 1.855709433555603,
+    "palette_chroma": 30.90544319152832,
+    "output_chroma": 19.500049591064453
+  },
+  {
+    "image": "07.jpg",
+    "size": 384,
+    "mask_entropy": 1.8696938753128052,
+    "palette_chroma": 20.328649520874023,
+    "output_chroma": 11.265676498413086
+  },
+  {
+    "image": "07.jpg",
+    "size": 512,
+    "mask_entropy": 1.9025498628616333,
+    "palette_chroma": 20.42593765258789,
+    "output_chroma": 12.631791114807129
+  }
+]

experiments/decision-20260928-v2/supplement/cache_loader_check.json

@@ -0,0 +1,8 @@
+{
+  "old_seconds": 0.6009589720001713,
+  "new_seconds": 0.010625808999975561,
+  "speedup": 56.556538142324364,
+  "exact_same_targets": true,
+  "synthetic_rows": 128,
+  "selected_rows": 64
+}

experiments/decision-20260928-v2/supplement/nara_sources.json

@@ -0,0 +1,50 @@
+[
+  {
+    "name": "nara_42.jpg",
+    "title": "Power station",
+    "source": "https://www.archives.gov/exhibits/picturing_the_century/greatdep/greatdep_img42.html",
+    "image_url": "https://www.archives.gov/exhibits/picturing_the_century/images/greatdep_042_v71.jpg",
+    "sha256": "a73186b25853d95a8e1785d1497923c1052747e8b045c5eac4c05dade60b2e87",
+    "bytes": 47847
+  },
+  {
+    "name": "nara_43.jpg",
+    "title": "Boxing team",
+    "source": "https://www.archives.gov/exhibits/picturing_the_century/greatdep/greatdep_img43.html",
+    "image_url": "https://www.archives.gov/exhibits/picturing_the_century/images/greatdep_043_v69.jpg",
+    "sha256": "f22dc07c4bdd0f3dac4b65ff0548395dc9aa88d8169a714fc40524249233b977",
+    "bytes": 40864
+  },
+  {
+    "name": "nara_44.jpg",
+    "title": "Street corner",
+    "source": "https://www.archives.gov/exhibits/picturing_the_century/greatdep/greatdep_img44.html",
+    "image_url": "https://www.archives.gov/exhibits/picturing_the_century/images/greatdep_044_v73.jpg",
+    "sha256": "c5e9a3fa57a6a0789e4b1529910e0294d98f245b24d205a1caccd08a5a3069b2",
+    "bytes": 68857
+  },
+  {
+    "name": "nara_45.jpg",
+    "title": "Children and sugar beets",
+    "source": "https://www.archives.gov/exhibits/picturing_the_century/greatdep/greatdep_img45.html",
+    "image_url": "https://www.archives.gov/exhibits/picturing_the_century/images/greatdep_045_v75.jpg",
+    "sha256": "3a3e3900cdb1384ca028a0a8843dcbcf499ffdd34832bc6b2e3f477d520403ae",
+    "bytes": 66706
+  },
+  {
+    "name": "nara_46.jpg",
+    "title": "Abandoned house",
+    "source": "https://www.archives.gov/exhibits/picturing_the_century/greatdep/greatdep_img46.html",
+    "image_url": "https://www.archives.gov/exhibits/picturing_the_century/images/greatdep_046_v76.jpg",
+    "sha256": "e7f2881c420c51c1855eb64219dc8c31e9a112976a3c81bfe0bcacb690d6b6e8",
+    "bytes": 74972
+  },
+  {
+    "name": "nara_49.jpg",
+    "title": "Man in his home",
+    "source": "https://www.archives.gov/exhibits/picturing_the_century/greatdep/greatdep_img49.html",
+    "image_url": "https://www.archives.gov/exhibits/picturing_the_century/images/greatdep_049_v72.jpg",
+    "sha256": "6d46bcc386aabf2dc090b2a05baf2e3ead04bc1274c38d87a60e1806ecfb4bab",
+    "bytes": 54941
+  }
+]

experiments/decision-20260928-v2/supplement/resolution_review.py

@@ -0,0 +1,27 @@
+"""Resolution-only review on fixed historical inputs; no training or pixel editing."""
+import json,time
+from pathlib import Path
+import torch
+from PIL import Image,ImageDraw,ImageOps
+from decision_model import load_decision
+from inference import colorize,prepare
+root=Path(__file__).resolve().parent
+torch.set_num_threads(4)
+m=load_decision(root/'smoke/mobilenet1')
+records=json.loads((root/'archive_inputs/nara_sources.json').read_text())
+rows=[]
+for start in range(0,len(records),3):
+ canvas=Image.new('RGB',(1280,344*len(records[start:start+3])),'white');draw=ImageDraw.Draw(canvas)
+ for j,item in enumerate(records[start:start+3]):
+  im=Image.open(root/'archive_inputs'/item['name']).convert('L').convert('RGB')
+  draw.text((3,j*344+3),item['title']+' | Input | 256 | 384 | 512',fill='black')
+  canvas.paste(ImageOps.pad(im,(320,320),color='white'),(0,j*344+24))
+  for col,size in enumerate([256,384,512],1):
+   t=time.monotonic();pred=colorize(m,im,size=size,radius=8)
+   canvas.paste(ImageOps.pad(pred,(320,320),color='white'),(col*320,j*344+24))
+   with torch.no_grad():
+    details=m(prepare(im,size)[2],True);w=details['weights'].clamp_min(1e-8)
+   rows.append({'name':item['name'],'size':size,'seconds_cpu':time.monotonic()-t,'mask_entropy':float(-(w*w.log()).sum(1).mean()),'output_chroma':float(details['output'].norm(dim=1).mean())})
+ canvas.save(root/f'baseline_nara_resolution_{start//3}.jpg',quality=94)
+(root/'baseline_nara_resolution.json').write_text(json.dumps(rows,indent=2))
+print('Rendered',len(records),'historical photographs at three resolutions.')