Colorizer round6: preflight passed before data preparation

experiments/medium-critic-20260928/SHA256SUMS.json

@@ -0,0 +1,26 @@
+{
+  "data_and_eval.py": "019ea992052f0233954b86e06e31c85c74ca313e67a55ff7fb03248f8874aaf5",
+  "initial/README.md": "2508e51f14898f651c49adb184d1570b8adad3702313dee9bdac6fa0390d2bec",
+  "initial/config.json": "eaeb49b39f9116bfed0d954e81852dc93476298752787dba88a63c0eec97ccec",
+  "initial/model.safetensors": "ec1f27d74533adc83f7ab3639a091fc4d8738a434dafc7d172c7873c28a9e715",
+  "protocol.json": "6e08c212bb5cf106047fee69cca20b64d119055f8e871fdf62b349b70fd594d1",
+  "smoke.json": "390beb83fcbfe9b00bd1159092e05c066026172bf147bc382e20461cda45993e",
+  "source/__pycache__/data.cpython-311.pyc": "526112ecc37d2691497f7ef76b527361af7b49f1771f4dfb9f3c7c9c751b237c",
+  "source/__pycache__/legacy_eval.cpython-311.pyc": "25bc477f5fa66a8da0cf57fbc0c10f56047360f461056b863b1ea458680bb610",
+  "source/__pycache__/metrics.cpython-311.pyc": "de27195e97d9c9736879f6d71eb5003d39b87fe32921f6032dacbc27d877bde9",
+  "source/__pycache__/model.cpython-311.pyc": "bba35c57917ce7694d9cbd7453fdd732bf8bf188637ed2344744a29b46eb8704",
+  "source/__pycache__/objectives.cpython-311.pyc": "93c9a025eb4ef7b90b7ab5e9afb0f3a922151ea460426eb2d89c5a8ca953a7fe",
+  "source/__pycache__/persistence.cpython-311.pyc": "e2faff82ba28c5f1d11dbbffc980d44666b0ab24fe66bc31412ded9a9461e608",
+  "source/__pycache__/semantic_model.cpython-311.pyc": "2d4ee1e0549f5f1f4a2665b4ef5d5e169231e044fe47abeec4af7cddffc506e0",
+  "source/__pycache__/spatial.cpython-311.pyc": "191dfa051e73c71512eed82ea9b992242cc4ad4ce34568a88ea1bff0c602876a",
+  "source/data.py": "eb43b886fe45435841439c36646985f914386a48faa712fb6806accac2ad48e0",
+  "source/legacy_eval.py": "dd7e8bd5f961dfb6f1c2ce98fac41824c5009188e306000b195e922e4ed03e58",
+  "source/metrics.py": "af0ac996f6be0a351a55e372fab637a0d06740afe4a744cb80d0eae56ec97f66",
+  "source/model.py": "4cc57f82ffd6378bdf23a088ce7a1ed56c09e5673de3ee5232b8ee1cacc9be0a",
+  "source/objectives.py": "133e85b6f2914c0e3803cc26a26fa29b779a49036219dd245c2ecfe0ba411e20",
+  "source/persistence.py": "8b26dd8acdc135ecbfcdd30b7f7723feb6008ac820c083403da1e820bdc15d33",
+  "source/previous_manifest.json": "24bc081bf48f1109d9dfa217ae0d8593c0c06af6785a5cbfc5dc5d9e25461f5c",
+  "source/semantic_model.py": "b019358cbcaa214743cbd244d20eb6e59eeff0ab5264093ec0927be8529b25a2",
+  "source/spatial.py": "d13abe399ef049e21a6459a7003461afaae0c00e0c560262c6cf375de4c9884a",
+  "train.py": "44957be87bff1708f832ef5d8cb0fc8314ac7d727777c39b82bb50ea37fb8037"
+}

experiments/medium-critic-20260928/data_and_eval.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/medium-critic-20260928/initial/README.md

@@ -0,0 +1,5 @@
+# Experimental semantic colorizer
+
+Head: palette. Parameters: 3994676.
+
+Not 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.

experiments/medium-critic-20260928/initial/config.json

@@ -0,0 +1,7 @@
+{
+  "architecture": "SemanticColorizer",
+  "head": "palette",
+  "width": 128,
+  "queries": 16,
+  "format_version": 1
+}

experiments/medium-critic-20260928/initial/model.safetensors

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

experiments/medium-critic-20260928/protocol.json

@@ -0,0 +1,25 @@
+{
+  "generator_parameters": 3994676,
+  "critic_parameters": 11623043,
+  "base_revision": "1a9eb8af2754ad2329a24cfe50d388cb559441d0",
+  "steps": 8000,
+  "batch_size": 16,
+  "seed": 92815,
+  "warmup_critic_updates": 500,
+  "generator_objective": "ONLY non-saturating conditional adversarial logistic loss, equally weighted global and two patch heads; no reconstruction, teacher, perceptual, feature matching, hue-target, or smoothing loss",
+  "critic": "ImageNet pretrained ResNet18, RGB+L conditioning, global plus layer2/layer3 patch heads; all weights trainable with frozen BatchNorm statistics",
+  "regularization": "D-only lazy R1 gamma=10 every16 updates on8 samples; adaptive translation augmentation target real-positive fraction0.6; identical transforms for real/fake; EMA0.999",
+  "generator_optimizer": "Adam encoder1e-6 decoder2e-5; warmup500 then cosine floor0.2, no weight decay",
+  "critic_optimizer": "Adam pretrained2e-5 newheads1e-4; betas0,0.99",
+  "data": "up to60000 real train photographs; pinned COCO/Imagenette; original fold excluded; exact-byte train/eval duplicates removed; no teacher outputs",
+  "checkpoint_interval": 250,
+  "evaluation_interval": 1000,
+  "hard_timeout_hours": 1.1,
+  "graceful_training_budget_hours": 0.85,
+  "release_policy": "experiment folder only; compare grids with v3 and previous 27M candidate; no automatic replacement of v3; critic score not used to approve production",
+  "research": [
+    "https://arxiv.org/abs/2006.06676",
+    "https://arxiv.org/abs/1703.10593"
+  ],
+  "limitations": "deterministic colouriser; one seed; adversarial loss can still collapse or exploit critic; grayscale is sometimes correct; no universal quality guarantee"
+}

experiments/medium-critic-20260928/smoke.json

@@ -0,0 +1,7 @@
+{
+  "backward_finite": true,
+  "R1_second_derivative": true,
+  "checkpoint_roundtrip": true,
+  "generator_parameters": 3994676,
+  "critic_parameters": 11623043
+}

experiments/medium-critic-20260928/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/medium-critic-20260928/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/medium-critic-20260928/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/medium-critic-20260928/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/medium-critic-20260928/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/medium-critic-20260928/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/medium-critic-20260928/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/medium-critic-20260928/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/medium-critic-20260928/train.py

@@ -0,0 +1,261 @@
+
+import os,sys,time,json,hashlib,shutil,random,copy,math,traceback,io
+from pathlib import Path
+import numpy as np
+import torch
+from torch import nn
+import torch.nn.functional as F
+from torch.utils.data import Dataset,DataLoader
+from torchvision.models import resnet18,ResNet18_Weights
+from torchvision.transforms import RandomResizedCrop
+from torchvision.transforms import functional as TF
+from PIL import Image
+from skimage.color import rgb2lab
+import pyarrow as pa
+import pyarrow.parquet as pq
+from huggingface_hub import HfApi,hf_hub_download
+REPO='User-2468/mini-unet-colorizer'
+BASE='1a9eb8af2754ad2329a24cfe50d388cb559441d0'
+PREFIX='experiments/medium-critic-20260928'
+WORK=Path('/work');WORK.mkdir(exist_ok=True);os.chdir(WORK)
+START=time.monotonic();MAX_SECONDS=.85*3600
+api=HfApi(token=os.environ['HF_TOKEN']);assert api.whoami()['name']=='User-2468'
+src='experiments/final-20260928/realism_low_v2'
+source=WORK/'source';source.mkdir(exist_ok=True)
+sums=json.loads(Path(hf_hub_download(REPO,src+'/SHA256SUMS.json',revision=BASE)).read_text())
+for f in ['data.py','legacy_eval.py','metrics.py','model.py','objectives.py','persistence.py','previous_manifest.json','semantic_model.py','spatial.py']:
+    p=Path(hf_hub_download(REPO,src+'/source/'+f,revision=BASE))
+    assert hashlib.sha256(p.read_bytes()).hexdigest()==sums['source/'+f]
+    shutil.copy2(p,source/f)
+shutil.copy2(hf_hub_download(REPO,src+'/data_and_eval.py',revision=BASE),WORK/'r7.py')
+sys.path.insert(0,str(source));sys.path.insert(0,str(WORK))
+import r7 as r
+from semantic_model import load_semantic,save_semantic
+from data import decode_image
+r.persistence.PREFIX=PREFIX
+OUT=r.OUT;durable=r.persistence.DurableRun(OUT)
+initial=WORK/'initial';initial.mkdir(exist_ok=True)
+for f in ['model.safetensors','config.json']:
+    shutil.copy2(hf_hub_download(REPO,f,revision=BASE),initial/f)
+r.ev.deadline=lambda:None
+SEED=92815;STEPS=8000;BATCH=16
+torch.set_num_threads(8);torch.manual_seed(SEED);random.seed(SEED);np.random.seed(SEED)
+torch.backends.cudnn.benchmark=True
+torch.backends.cuda.matmul.allow_tf32=True
+torch.backends.cudnn.allow_tf32=True
+
+def lab_rgb(L,ab):
+    # Equal chroma bandwidth in real/fake critic inputs prevents a trivial resize shortcut.
+    ab=F.interpolate(F.avg_pool2d(ab.float(),4),L.shape[-2:],mode='bilinear',align_corners=False)
+    light=L.float()*50+50
+    y=(light+16)/116;x=y+ab[:,0:1]/500;z=y-ab[:,1:2]/200
+    xyz=torch.cat([x,y,z],1)
+    xyz=torch.where(xyz>6/29,xyz**3,(xyz-4/29)*3*(6/29)**2)
+    xyz=xyz*xyz.new_tensor([.95047,1,1.08883])[None,:,None,None]
+    matrix=xyz.new_tensor([[3.2404542,-1.5371385,-.4985314],[-.969266,1.8760108,.041556],[.0556434,-.2040259,1.0572252]])
+    lin=torch.einsum('ij,bjhw->bihw',matrix,xyz)
+    rgb=torch.where(lin>.0031308,1.055*lin.clamp_min(1e-8).pow(1/2.4)-.055,12.92*lin)
+    return rgb.clamp(0,1)
+
+def pair(L,ab):
+    rgb=lab_rgb(L,ab)
+    return torch.cat([(rgb-rgb.new_tensor([.485,.456,.406])[None,:,None,None])/rgb.new_tensor([.229,.224,.225])[None,:,None,None],L.float()],1)
+
+class Critic(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net=resnet18(weights=ResNet18_Weights.IMAGENET1K_V1,progress=False)
+        old=self.net.conv1
+        self.net.conv1=nn.Conv2d(4,64,7,2,3,bias=False)
+        with torch.no_grad():
+            self.net.conv1.weight[:,:3].copy_(old.weight);self.net.conv1.weight[:,3:].zero_()
+        self.net.fc=nn.Linear(512,1)
+        self.patch2=nn.Sequential(nn.Conv2d(128,128,3,padding=1),nn.LeakyReLU(.2),nn.Conv2d(128,1,1))
+        self.patch3=nn.Sequential(nn.Conv2d(256,128,3,padding=1),nn.LeakyReLU(.2),nn.Conv2d(128,1,1))
+    def train(self,mode=True):
+        super().train(mode)
+        # Fixed population statistics prevent batch composition and tiny R1 batches becoming shortcuts.
+        for mod in self.modules():
+            if isinstance(mod,nn.BatchNorm2d):mod.eval()
+        return self
+    def forward(self,x):
+        n=self.net
+        x=n.maxpool(n.relu(n.bn1(n.conv1(x))))
+        x=n.layer1(x);x=n.layer2(x);p2=self.patch2(x).flatten(1)
+        x=n.layer3(x);p3=self.patch3(x).flatten(1)
+        x=n.layer4(x);g=n.fc(n.avgpool(x).flatten(1))
+        return [g,p2,p3]
+
+def loss_real(scores):return sum(F.softplus(-s).mean() for s in scores)/len(scores)
+def loss_fake(scores):return sum(F.softplus(s).mean() for s in scores)/len(scores)
+def score_mean(scores):return torch.stack([s.mean(1) for s in scores]).mean(0)
+
+def augment(x,p):
+    # Geometric only; no colour jitter that could teach the critic to accept wrong chroma.
+    if random.random()<p:
+        h,w=x.shape[-2:];dy=random.randint(-16,16);dx=random.randint(-16,16)
+        x=F.pad(x,(16,16,16,16),mode='reflect')[:,:,16+dy:16+dy+h,16+dx:16+dx+w]
+    return x
+
+class Photos(Dataset):
+    def __init__(self,table,ids):self.table,self.ids=table,ids
+    def __len__(self):return len(self.ids)
+    def __getitem__(self,k):
+        im=decode_image(self.table,self.ids[k]).convert('RGB')
+        i,j,h,w=RandomResizedCrop.get_params(im,scale=(.65,1.),ratio=(.85,1.18))
+        im=TF.resized_crop(im,i,j,h,w,[256,256],interpolation=TF.InterpolationMode.BILINEAR)
+        if random.random()<.5:im=TF.hflip(im)
+        rgb=np.asarray(im,np.float32)/255
+        lab=rgb2lab(rgb).astype(np.float32)
+        # Half neutral L, half standard photographic RGB grayscale; equal real/fake L.
+        if random.random()<.5:L=lab[...,0]
+        else:
+            g=np.asarray(im.convert('L'),np.float32)/255
+            L=rgb2lab(np.repeat(g[...,None],3,-1))[...,0].astype(np.float32)
+        return torch.from_numpy((L[None]/50-1).copy()),torch.from_numpy(lab[...,1:].transpose(2,0,1).copy())
+
+def save(step,model,ema,critic,opt,dopt,history,p,phase):
+    save_semantic(model,OUT/f'step_{step:05d}'/'raw')
+    save_semantic(ema,OUT/f'step_{step:05d}'/'ema')
+    torch.save({'step':step,'generator':model.state_dict(),'ema':ema.state_dict(),'critic':critic.state_dict(),'optimizer':opt.state_dict(),'critic_optimizer':dopt.state_dict(),'augmentation_probability':p,'torch_rng':torch.get_rng_state(),'cuda_rng':torch.cuda.get_rng_state_all(),'numpy_rng':np.random.get_state(),'python_rng':random.getstate(),'note':'Resume optimizer/model state; loader position is not serialized.'},OUT/'latest_training_state.pt')
+    r.write('history.json',history)
+    r.write('status.json',{'status':phase,'step':step,'elapsed_seconds':time.monotonic()-START,'production_approved':False})
+    durable.sync('large critic '+phase+' step '+str(step))
+
+def main():
+    shutil.copytree(source,OUT/'source',dirs_exist_ok=True)
+    shutil.copy2('/work/train.py',OUT/'train.py')
+    shutil.copy2('/work/r7.py',OUT/'data_and_eval.py')
+    model=load_semantic(initial,'cuda');ema=copy.deepcopy(model).eval().requires_grad_(False)
+    critic=Critic().cuda()
+    gc=sum(p.numel() for p in model.parameters());dc=sum(p.numel() for p in critic.parameters())
+    assert gc==3994676 and 10_000_000<dc<15_000_000
+    protocol={'generator_parameters':gc,'critic_parameters':dc,'base_revision':BASE,'steps':STEPS,'batch_size':BATCH,'seed':SEED,'warmup_critic_updates':500,'generator_objective':'ONLY non-saturating conditional adversarial logistic loss, equally weighted global and two patch heads; no reconstruction, teacher, perceptual, feature matching, hue-target, or smoothing loss','critic':'ImageNet pretrained ResNet18, RGB+L conditioning, global plus layer2/layer3 patch heads; all weights trainable with frozen BatchNorm statistics','regularization':'D-only lazy R1 gamma=10 every16 updates on8 samples; adaptive translation augmentation target real-positive fraction0.6; identical transforms for real/fake; EMA0.999','generator_optimizer':'Adam encoder1e-6 decoder2e-5; warmup500 then cosine floor0.2, no weight decay','critic_optimizer':'Adam pretrained2e-5 newheads1e-4; betas0,0.99','data':'up to60000 real train photographs; pinned COCO/Imagenette; original fold excluded; exact-byte train/eval duplicates removed; no teacher outputs','checkpoint_interval':250,'evaluation_interval':1000,'hard_timeout_hours':1.1,'graceful_training_budget_hours':0.85,'release_policy':'experiment folder only; compare grids with v3 and previous 27M candidate; no automatic replacement of v3; critic score not used to approve production','research':['https://arxiv.org/abs/2006.06676','https://arxiv.org/abs/1703.10593'],'limitations':'deterministic colouriser; one seed; adversarial loss can still collapse or exploit critic; grayscale is sometimes correct; no universal quality guarantee'}
+    r.write('protocol.json',protocol)
+    opt=torch.optim.Adam([{'params':model.encoder.parameters(),'lr':1e-6,'base_lr':1e-6},{'params':[v for k,v in model.named_parameters() if not k.startswith('encoder.')],'lr':2e-5,'base_lr':2e-5}],betas=(0.0,.99))
+    pretrained=[v for k,v in critic.named_parameters() if k.startswith('net.') and not k.startswith('net.fc')]
+    heads=[v for k,v in critic.named_parameters() if not k.startswith('net.') or k.startswith('net.fc')]
+    dopt=torch.optim.Adam([{'params':pretrained,'lr':2e-5},{'params':heads,'lr':1e-4}],betas=(0.0,.99))
+    # Real backward + lazy R1 + checkpoint roundtrip before costly data preparation.
+    L=torch.zeros(2,1,256,256,device='cuda')
+    pred=model(L);critic.eval()
+    loss=loss_real(critic(pair(L,pred)));loss.backward()
+    assert all(torch.isfinite(v.grad).all() for v in model.parameters() if v.grad is not None)
+    x=pair(L,torch.zeros_like(pred)).detach().requires_grad_(True)
+    grad=torch.autograd.grad(score_mean(critic(x)).sum(),x,create_graph=True)[0]
+    (grad.square().flatten(1).sum(1).mean()*5).backward()
+    model.zero_grad(set_to_none=True);critic.zero_grad(set_to_none=True)
+    del L,pred,loss,x,grad
+    save_semantic(model,OUT/'initial')
+    reload=load_semantic(OUT/'initial','cuda')
+    for k,v in model.state_dict().items():assert torch.equal(v,reload.state_dict()[k])
+    del reload
+    r.write('smoke.json',{'backward_finite':True,'R1_second_derivative':True,'checkpoint_roundtrip':True,'generator_parameters':gc,'critic_parameters':dc})
+    durable.sync('preflight passed before data preparation')
+    print('PREFLIGHT_PASSED',gc,dc,flush=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((source/'previous_manifest.json').read_text())
+    ids=list(manifest['train']);provenance=[]
+    files=sorted(f for f in api.list_repo_files('detection-datasets/coco',repo_type='dataset',revision='26ddc382fe75dfc2a0655b5977e296ea10efebce') if f.startswith('default/train/') and f.endswith('.parquet') and not f.endswith(('/0000.parquet','/0001.parquet')))
+    for f in files:
+        if len(ids)>=60000:break
+        extra=pq.read_table(hf_hub_download('detection-datasets/coco',f,repo_type='dataset',revision='26ddc382fe75dfc2a0655b5977e296ea10efebce'),columns=['image'])
+        offset=len(table);take=min(len(extra),60000-len(ids));ids.extend(range(offset,offset+take))
+        table=pa.concat_tables([table,extra]);provenance.append({'file':f,'take':take})
+    fresh=pq.read_table(hf_hub_download('detection-datasets/coco','default/val/0001.parquet',repo_type='dataset',revision='26ddc382fe75dfc2a0655b5977e296ea10efebce'),columns=['image'])
+    prior=json.loads(Path(hf_hub_download(REPO,'experiments/round7-20260928/manifest.json',revision=BASE)).read_text())
+    excluded=set(prior['development']+prior['heldout'])
+    candidates=[int(i) for i in np.random.default_rng(SEED).permutation(len(fresh)) if int(i) not in excluded][:512]
+    dev=candidates[:128];held=candidates[128:]
+    evalhash={hashlib.sha256(fresh['image'][i].as_py()['bytes']).digest() for i in candidates}
+    ids=[i for i in ids if hashlib.sha256(table['image'][i].as_py()['bytes']).digest() not in evalhash]
+    # Real colour data only, but retain naturally neutral regions within these photos.
+    keep=[]
+    for i in ids:
+        im=decode_image(table,i).resize((32,32)).convert('RGB')
+        lab=rgb2lab(np.asarray(im,np.float32)/255)
+        if float(np.linalg.norm(lab[...,1:],axis=-1).mean())>=4:keep.append(i)
+    ids=keep
+    r.write('manifest.json',{'train':ids,'development':dev,'heldout':held,'additional_train_shards':provenance,'coco_revision':'26ddc382fe75dfc2a0655b5977e296ea10efebce','imagenette_revision':'771c1310a2487e8076ede6b7d6307244aa8400af','exact_duplicate_filter':True,'near_duplicates_not_excluded':True,'heldout_not_used_for_checkpoint_selection':True})
+    baseline=load_semantic(initial,'cuda')
+    olddir=WORK/'prior_27m';olddir.mkdir(exist_ok=True)
+    for fn in ['model.safetensors','config.json']:
+        shutil.copy2(hf_hub_download(REPO,'experiments/large-critic-20260928/candidate/'+fn,revision='main'),olddir/fn)
+    oldcandidate=load_semantic(olddir,'cuda')
+    r.write('baseline_development.json',r.ev.evaluate(baseline,fresh,dev))
+    durable.sync('data and fresh evaluation split persisted')
+    loader=DataLoader(Photos(table,ids),batch_size=BATCH,shuffle=True,num_workers=8,pin_memory=True,drop_last=True,persistent_workers=True,generator=torch.Generator().manual_seed(SEED))
+    it=iter(loader);history=[];augp=.2;real_signs=[];step=0;stopreason='completed'
+    for update in range(1,STEPS+501):
+        if time.monotonic()-START>MAX_SECONDS:stopreason='time_budget';break
+        model.train();critic.train()
+        for mod in model.encoder.modules():
+            if isinstance(mod,nn.BatchNorm2d):mod.eval()
+        try:L,ab=next(it)
+        except StopIteration:it=iter(loader);L,ab=next(it)
+        L,ab=L.cuda(non_blocking=True),ab.cuda(non_blocking=True)
+        # D update. Generator graph is constructed only for its own update.
+        with torch.no_grad(),torch.autocast('cuda',dtype=torch.bfloat16):pred=model(L)
+        for v in critic.parameters():v.requires_grad_(True)
+        dopt.zero_grad(set_to_none=True)
+        realx=pair(L,ab);fakex=pair(L,pred)
+        joined=augment(torch.cat([realx,fakex],0),augp)
+        with torch.autocast('cuda',dtype=torch.bfloat16):
+            scores=critic(joined)
+            real=[s[:BATCH].float() for s in scores];fake=[s[BATCH:].float() for s in scores]
+            dl=loss_real(real)+loss_fake(fake)
+        dl.backward()
+        r1value=0.
+        if update%16==0:
+            rx=realx[:8].detach().requires_grad_(True)
+            rs=score_mean(critic(rx))
+            rg=torch.autograd.grad(rs.sum(),rx,create_graph=True)[0]
+            r1=rg.square().flatten(1).sum(1).mean()
+            (r1*(10/2)*16).backward();r1value=float(r1.detach())
+        torch.nn.utils.clip_grad_norm_(critic.parameters(),10,error_if_nonfinite=True);dopt.step()
+        real_signs.append(float((score_mean(real).detach()>0).float().mean()))
+        if update%100==0:
+            augp=float(np.clip(augp+np.sign(np.mean(real_signs)-.6)*BATCH*100/500000,0,.8));real_signs=[]
+        glvalue=None
+        if update>500:
+            step=update-500
+            for v in critic.parameters():v.requires_grad_(False)
+            critic.eval();opt.zero_grad(set_to_none=True)
+            mult=min(step/500,1)*(.2+.8*(1+math.cos(math.pi*step/STEPS))/2)
+            for group in opt.param_groups:group['lr']=group['base_lr']*mult
+            with torch.autocast('cuda',dtype=torch.bfloat16):
+                pred=model(L)
+                gl=loss_real([s.float() for s in critic(augment(pair(L,pred),augp))])
+            gl.backward();torch.nn.utils.clip_grad_norm_(model.parameters(),1,error_if_nonfinite=True);opt.step()
+            glvalue=float(gl.detach())
+            with torch.no_grad():
+                for ep,p in zip(ema.parameters(),model.parameters()):ep.lerp_(p,.001)
+                for eb,b in zip(ema.buffers(),model.buffers()):eb.copy_(b)
+        if update%100==0:
+            item={'update':update,'generator_step':step,'D':float(dl.detach()),'G':glvalue,'R1':r1value,'augmentation_p':augp,'real_score':float(score_mean(real).detach().mean()),'fake_score':float(score_mean(fake).detach().mean()),'elapsed_seconds':time.monotonic()-START}
+            history.append(item);print('TRAIN',json.dumps(item),flush=True)
+        if update==500 or (step>0 and step%250==0):
+            save(step,model,ema,critic,opt,dopt,history,augp,'training')
+            if step==0 or step%1000==0:
+                r.write(f'development_{step:05d}.json',r.ev.evaluate(ema,fresh,dev))
+                r.grid({'v3':baseline,'prior27':oldcandidate,'ema':ema,'raw':model.eval()},fresh,dev[:24],f'comparison_{step:05d}')
+                r.ev.probes(ema,f'probes_{step:05d}')
+                durable.sync('development review '+str(step))
+    save(step,model,ema,critic,opt,dopt,history,augp,'training_finished')
+    # Held-out report only after training; no best-checkpoint claims based on critic scores.
+    for name,m in [('v3',baseline),('prior27',oldcandidate),('final_ema',ema),('final_raw',model.eval())]:
+        r.write(name+'_heldout.json',r.ev.evaluate(m,fresh,held))
+        r.review(m,fresh,held[:80],name)
+    r.grid({'v3':baseline,'prior27':oldcandidate,'ema':ema,'raw':model.eval()},fresh,held[:32],'heldout_comparison')
+    save_semantic(ema,OUT/'candidate')
+    r.write('status.json',{'status':'completed','generator_steps':step,'stop_reason':stopreason,'elapsed_seconds':time.monotonic()-START,'production_approved':False,'next':'Review developmental checkpoint grids and held-out comparisons; this job does not automatically replace v3.'})
+    durable.sync('completed candidate and independent reports')
+
+try:
+    main()
+except BaseException:
+    r.write('failure.json',{'traceback':traceback.format_exc().replace(os.environ.get('HF_TOKEN','__EMPTY__'),'[REDACTED]')})
+    durable.sync('failure report and saved checkpoints')
+    raise