Spaces:
Sleeping
Sleeping
Download model_code/train.py from oussamab2n/GazeLIFT: direct link, hf CLI and curl.
- Browser
- Download file 11.9 kB
-
https://huggingface.co/spaces/oussamab2n/GazeLIFT/resolve/main/model_code/train.py
- Command line
-
hf download hf://spaces/oussamab2n/GazeLIFT/model_code/train.py
-
curl -L -o train.py https://huggingface.co/spaces/oussamab2n/GazeLIFT/resolve/main/model_code/train.py
11.9 kB
| """Fresh training of the one shared fuse-then-gaze architecture. Validation only.""" | |
| from pathlib import Path | |
| import argparse,csv,hashlib,json,math,random,time | |
| import copy | |
| import numpy as np | |
| from PIL import Image | |
| import torch | |
| import torch.nn.functional as F | |
| from torch.utils.data import DataLoader | |
| from model import TransposeCNNGazePyramidDecoder,segmentation_loss | |
| from data import FeatureImageDataset,collate,load_torch | |
| def emit(x):print(json.dumps(x),flush=True) | |
| def atomic_json(path,value): | |
| temp=path.with_suffix('.tmp');temp.write_text(json.dumps(value,indent=2));temp.replace(path) | |
| def patient(name):return name.rsplit('_',1)[0] | |
| def fingerprint(model): | |
| digest=hashlib.sha256() | |
| for name,p in model.state_dict().items():digest.update(name.encode());digest.update(p.detach().cpu().contiguous().numpy().tobytes()) | |
| return digest.hexdigest() | |
| def inputs(batch): | |
| return (batch['image'].cuda(non_blocking=True).float(), | |
| [f.cuda(non_blocking=True) for f in batch['features']],batch['gaze'].cuda(non_blocking=True).float()) | |
| def dice_iou(probability,target): | |
| p=probability>.5;t=target>.5;inter=(p&t).sum().item() | |
| return (2*inter+1e-6)/(p.sum().item()+t.sum().item()+1e-6),(inter+1e-6)/((p|t).sum().item()+1e-6) | |
| def evaluate(model,loader,masks=None): | |
| model.eval();records=[] | |
| for batch in loader: | |
| probabilities=model(*inputs(batch)).sigmoid().float().cpu() | |
| for i,name in enumerate(batch['id']): | |
| native=batch['native'][i] | |
| p=F.interpolate(probabilities[i:i+1],size=native.shape[-2:],mode='bilinear',align_corners=False)[0] | |
| dice,iou=dice_iou(p,native) | |
| records.append({'id':name,'patient':patient(name),'dice':dice,'iou':iou}) | |
| if masks is not None:Image.fromarray(((p[0]>.5).numpy()*255).astype(np.uint8)).save(masks/(name+'.png')) | |
| return records | |
| def summary(records): | |
| result={'n':len(records)} | |
| for key in ['dice','iou']: | |
| values=np.array([r[key] for r in records])*100 | |
| result[key+'_mean']=float(values.mean());result[key+'_case_sd']=float(values.std(ddof=1)) | |
| return result | |
| def main(): | |
| ap=argparse.ArgumentParser() | |
| ap.add_argument('--dataset',choices=['kvasir','prostate'],required=True) | |
| ap.add_argument('--manifest',required=True);ap.add_argument('--existing-cache',required=True) | |
| ap.add_argument('--sigma-px',type=float,required=True);ap.add_argument('--output',required=True) | |
| ap.add_argument('--seed',type=int,default=42);ap.add_argument('--epochs',type=int,default=80) | |
| ap.add_argument('--patience',type=int,default=15);ap.add_argument('--batch-size',type=int,default=4) | |
| ap.add_argument('--accumulation',type=int,default=2);ap.add_argument('--lr',type=float,default=2e-4) | |
| args=ap.parse_args();assert args.seed==42 and torch.cuda.is_available() | |
| torch.set_num_threads(4);random.seed(args.seed);np.random.seed(args.seed) | |
| torch.manual_seed(args.seed);torch.cuda.manual_seed_all(args.seed) | |
| torch.backends.cudnn.benchmark=False;torch.backends.cudnn.deterministic=True;torch.backends.cuda.matmul.allow_tf32=True | |
| root=Path(args.output);root.mkdir(parents=True,exist_ok=True);assert not (root/'settings.json').exists() | |
| manifest=json.loads(Path(args.manifest).read_text());assert manifest['dataset']==args.dataset | |
| for a,b in [('train','validation'),('train','test'),('validation','test')]: | |
| assert not set(manifest[a])&set(manifest[b]) | |
| if args.dataset=='prostate':assert not {patient(x) for x in manifest[a]}&{patient(x) for x in manifest[b]} | |
| cache=Path(args.existing_cache);ids=manifest['train']+manifest['validation']+manifest['test'] | |
| assert args.sigma_px==(32. if args.dataset=='kvasir' else 8.) | |
| meta=json.loads((cache/'cache_metadata.json').read_text()) | |
| assert meta['dataset']==args.dataset and meta['resolution']==512 and meta['blocks']==[6,12,18,24] | |
| assert meta['ids_sha256']==hashlib.sha256('\n'.join(ids).encode()).hexdigest() | |
| assert meta['training_code_sha256']=='661fe6a153c3519229f6e8dcb3fb500dff5737a090faff86998f861a80df6b3d' | |
| atomic_json(root/'cache_metadata.json',meta) | |
| sources={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in Path(__file__).parent.glob('*.py') if p.name in ['train.py','model.py','data.py','image_data.py','heatmap.py','base_model.py','wavelet.py','reference_model.py','width_reference.py','flat_reference.py','pointwise_reference.py','pyramid_reference.py','conv3_reference.py','selected_reference.py','transpose_reference.py']} | |
| model=TransposeCNNGazePyramidDecoder();params=sum(p.numel() for p in model.parameters()) | |
| initial_parameters={n:p.detach().cpu().clone() for n,p in model.named_parameters()} | |
| settings={**vars(args),'architecture':'gaze_pyramid_transpose_cnn_decoder_rgb','resolution':512,'counts':manifest['counts'], | |
| 'initialization':'all learned decoder/projection/conditioning weights newly random; wavelet Haar-initialized; only frozen pretrained DINO features retained', | |
| 'segmentation_checkpoint_loaded':False,'pretrained_encoder':'frozen DINOv3 ViT-L/16 cached features','dino_used':True,'wavelet_used':True,'dino_trainable_parameters':0, | |
| 'wavelet_channels':[12,12,12,12],'dino_blocks':[6,12,18,24],'dino_projection_channels':[32,64,128,256],'gaze_conditioned_widths':[32,64,128,256], | |
| 'decoder_widths':[32,32,32,32,32],'bottleneck_width':32,'decoder_input_channels':[268,172,108,76,35],'deep_fusion_input_channels':268,'full_resolution_skip':'original normalized RGB3 concatenated with upsampled decoder32','decoder_block':'one ConvTranspose2d3x3 per block:268/172/108/76/35->32; strides2/2/2/2/1,padding1,output_padding1/1/1/1/0,biasFalse,GN8,GELU; then Conv2d32->32 kernel3,padding1,biasFalse,GN8,GELU','skip_merge':'concatenate previous transposed-decoder32 at the current gaze/wavelet grid; fuse before next learned upsampling', | |
| 'gaze_duration_weighted':True,'heatmap_from_original_fixations':True,'sigma_units':'input pixels', | |
| 'background_subtraction':True,'prototype_features':'projected DINO32/64/128/256 ONLY, resized to each scale; never wavelet-fused', | |
| 'conditioning':'concat projected DINO,H1,C1; Conv1x1 inputs34/66/130/258, outputs32/64/128/256, GN8/GELU', | |
| 'encoder_recurrence':'DINO-only conditioning independently per depth; wavelet branch bypasses gaze and enters only deep decoder fusion and three decoder concatenations', | |
| 'pooling':'one learned8-coefficient lifting wavelet then three fixed average pools','upsampling':'decoder learned ConvTranspose2d; only DINO projection resizing remains fixed bilinear', | |
| 'knn':False,'prototype_iterations':0,'tta':False,'threshold':.5, | |
| 'loss':'BCEWithLogits + soft Dice, final head only','optimizer':'AdamW, weight_decay1e-4', | |
| 'schedule':'5 epoch linear warmup then cosine to 0.05x LR', | |
| 'augmentation':'paired H/V image, cached feature, full-resolution heatmap and mask flips; frozen DINO not re-encoded', | |
| 'data_rng_seed':args.seed+1000,'effective_batch_size':args.batch_size*args.accumulation, | |
| 'checkpoint_selection':'highest native validation mean Dice; no test use','test_evaluated':False, | |
| 'torch':torch.__version__,'gpu':torch.cuda.get_device_name(), | |
| 'manifest_sha256':hashlib.sha256(Path(args.manifest).read_bytes()).hexdigest(), | |
| 'sources_sha256':sources,'initial_model_fingerprint':fingerprint(model),'same_shaped_retained_modules_start_as_baseline':True,'trainable_parameters':params, | |
| 'component_parameters':{n:sum(p.numel() for p in getattr(model,n).parameters()) for n in ['wavelet','dino_projection','gaze_conditioning','decoder','mask_head']}} | |
| atomic_json(root/'settings.json',settings);emit({'phase':'random_initialization',**settings}) | |
| model=model.cuda() | |
| images={p.stem:p for p in (Path(manifest['root'])/'images').iterdir() if p.is_file()};assert set(ids)<=set(images) | |
| def loader(split,augment=False): | |
| dataset=FeatureImageDataset(cache,images,manifest[split],manifest,args.sigma_px,augment) | |
| atomic_json(root/f'{split}_gaze_audit.json',dataset.gaze_audit) | |
| return DataLoader(dataset,batch_size=args.batch_size,shuffle=augment,num_workers=0,pin_memory=True,collate_fn=collate) | |
| train_loader=loader('train',True);val_loader=loader('validation') | |
| optimizer=torch.optim.AdamW(model.parameters(),lr=args.lr,weight_decay=1e-4) | |
| def multiplier(epoch): | |
| if epoch<5:return (epoch+1)/5 | |
| progress=min(1.,(epoch-5)/max(args.epochs-5,1)) | |
| return .05+.95*.5*(1+math.cos(math.pi*progress)) | |
| scheduler=torch.optim.lr_scheduler.LambdaLR(optimizer,multiplier) | |
| torch.manual_seed(args.seed+1000);torch.cuda.manual_seed_all(args.seed+1000) | |
| initial=summary(evaluate(model,val_loader));atomic_json(root/'initial_validation.json',initial);emit({'phase':'initial_validation','metrics':initial}) | |
| best=initial['dice_mean'];best_epoch=0;stale=0;history=[];start=time.monotonic() | |
| torch.save({'model':model.state_dict(),'epoch':0,'validation':initial,'settings':settings},root/'best.pt') | |
| for epoch in range(1,args.epochs+1): | |
| model.train();total_loss=0.;seen=0;optimizer.zero_grad(set_to_none=True) | |
| for index,batch in enumerate(train_loader): | |
| logits=model(*inputs(batch));target=batch['mask'].cuda(non_blocking=True).float() | |
| loss=segmentation_loss(logits,target);assert torch.isfinite(loss) | |
| group_start=(index//args.accumulation)*args.accumulation | |
| examples=min(args.batch_size*args.accumulation,len(train_loader.dataset)-group_start*args.batch_size) | |
| (loss*(len(batch['id'])/examples)).backward() | |
| if (index+1)%args.accumulation==0 or index+1==len(train_loader): | |
| torch.nn.utils.clip_grad_norm_(model.parameters(),1.);optimizer.step();optimizer.zero_grad(set_to_none=True) | |
| total_loss+=loss.item()*len(batch['id']);seen+=len(batch['id']) | |
| val=summary(evaluate(model,val_loader));lr=optimizer.param_groups[0]['lr'];scheduler.step() | |
| record={'epoch':epoch,'train_loss':total_loss/seen,'lr':lr,'validation':val,'seconds':round(time.monotonic()-start,1)} | |
| history.append(record);atomic_json(root/'history.json',history);emit({'phase':'epoch',**record}) | |
| if val['dice_mean']>best+1e-5: | |
| best=val['dice_mean'];best_epoch=epoch;stale=0 | |
| torch.save({'model':model.state_dict(),'epoch':epoch,'validation':val,'settings':settings},root/'best.pt') | |
| else:stale+=1 | |
| if stale>=args.patience:break | |
| selected=load_torch(root/'best.pt');model.load_state_dict(selected['model']) | |
| records=evaluate(model,val_loader);chosen=summary(records);assert abs(chosen['dice_mean']-best)<1e-7 | |
| with (root/'validation_per_image.csv').open('w',newline='') as stream: | |
| writer=csv.DictWriter(stream,fieldnames=records[0]);writer.writeheader();writer.writerows(records) | |
| for name,digest in sources.items():assert hashlib.sha256((Path(__file__).parent/name).read_bytes()).hexdigest()==digest | |
| changes={n:float((p.detach().cpu()-initial_parameters[n]).norm()) for n,p in model.named_parameters()} | |
| assert all(v>1e-10 and np.isfinite(v) for v in changes.values()) | |
| atomic_json(root/'parameter_updates.json',changes) | |
| result={'dataset':args.dataset,'seed':args.seed,'best_epoch':best_epoch,'epochs_completed':len(history), | |
| 'validation':chosen,'training_seconds':time.monotonic()-start,'test_evaluated':False, | |
| 'initial_model_fingerprint':settings['initial_model_fingerprint'], | |
| 'checkpoint_sha256':hashlib.sha256((root/'best.pt').read_bytes()).hexdigest()} | |
| atomic_json(root/'train_summary.json',result);emit({'phase':'training_complete',**result}) | |
| if __name__=='__main__':main() | |