source/code/phase1_infer.py

"""Frozen GPU inference, image-level caching, and label-isolated CACP evaluation."""
from pathlib import Path
import argparse,json,time,os,hashlib,collections,platform
import numpy as np
from PIL import Image
from repair import query_plan,repaired_maps,visual_features,score_mask
ROOT=Path(__file__).resolve().parents[1]

class ClipSeg:
    threshold=.5
    def __init__(self):
        import torch
        from transformers import CLIPSegProcessor,CLIPSegForImageSegmentation
        self.torch=torch;path=ROOT/'assets/models/clipseg'
        self.processor=CLIPSegProcessor.from_pretrained(str(path),local_files_only=True)
        self.model=CLIPSegForImageSegmentation.from_pretrained(str(path),local_files_only=True).eval().cuda()
    def predict(self,image,texts):
        t=self.torch;out={}
        with t.inference_mode():
            for k in range(0,len(texts),8):
                batch=texts[k:k+8]
                inputs=self.processor(text=batch,images=[image]*len(batch),padding=True,truncation=True,return_tensors='pt').to('cuda')
                logits=self.model(**inputs,interpolate_pos_encoding=True).logits
                if logits.ndim==2:logits=logits[None]
                probs=t.nn.functional.interpolate(logits[:,None],size=(image.height,image.width),mode='bilinear',align_corners=False)[:,0].sigmoid()
                for q,p in zip(batch,probs):out[q]=p.float().cpu().numpy()
        return out,{'language_queries':len(texts),'sam_boxes':0,'truncated_boxes':0}

class GroundedSam:
    threshold=.25
    def __init__(self):
        import torch
        from transformers import AutoProcessor,AutoModelForZeroShotObjectDetection,SamProcessor,SamModel,GroundingDinoConfig
        self.torch=torch;p=ROOT/'assets/models/groundingdino';s=ROOT/'assets/models/sam'
        self.processor=AutoProcessor.from_pretrained(str(p),local_files_only=True)
        cfg=GroundingDinoConfig.from_pretrained(str(p),local_files_only=True);cfg.disable_custom_kernels=True
        self.model=AutoModelForZeroShotObjectDetection.from_pretrained(str(p),config=cfg,local_files_only=True).eval().cuda()
        self.samproc=SamProcessor.from_pretrained(str(s),local_files_only=True)
        self.sam=SamModel.from_pretrained(str(s),local_files_only=True).eval().cuda()
    def predict(self,image,texts):
        t=self.torch;allboxes=[];detections={};truncated=0;out={}
        with t.inference_mode():
            for k in range(0,len(texts),2):
                batch=texts[k:k+2]
                inputs=self.processor(images=[image]*len(batch),text=[q.strip(' .')+'.' for q in batch],padding=True,truncation=True,return_tensors='pt').to('cuda')
                pred=self.model(**inputs)
                det=self.processor.post_process_grounded_object_detection(pred,inputs.input_ids,box_threshold=.25,text_threshold=.25,target_sizes=[(image.height,image.width)]*len(batch))
                for q,d in zip(batch,det):
                    order=d['scores'].argsort(descending=True);truncated+=max(0,len(order)-30);order=order[:30]
                    entries=[]
                    for box,score in zip(d['boxes'][order].cpu().tolist(),d['scores'][order].cpu().tolist()):
                        box=[max(0,min(v,image.width if j%2==0 else image.height)) for j,v in enumerate(box)]
                        if box[2]-box[0]<1 or box[3]-box[1]<1:continue
                        key=tuple(round(v,1) for v in box)
                        if key not in allboxes:allboxes.append(key)
                        entries.append((allboxes.index(key),float(score)))
                    detections[q]=entries
            masks=[]
            if allboxes:
                ip=self.samproc(images=image,return_tensors='pt').to('cuda')
                emb=self.sam.get_image_embeddings(ip.pixel_values)
                for k in range(0,len(allboxes),16):
                    ins=self.samproc(images=image,input_boxes=[[list(b) for b in allboxes[k:k+16]]],return_tensors='pt').to('cuda')
                    pr=self.sam(image_embeddings=emb,input_boxes=ins.input_boxes,multimask_output=True)
                    chosen=pr.iou_scores[0].argmax(dim=-1)
                    low=pr.pred_masks[:,t.arange(len(chosen),device='cuda'),chosen,: ,:][:,:,None]
                    # Official postprocessing restores original image resolution.
                    full=self.samproc.image_processor.post_process_masks(low,ins.original_sizes,ins.reshaped_input_sizes,binarize=True)[0]
                    masks.extend(full[:,0].cpu().numpy().astype(bool))
            for q in texts:
                p=np.zeros((image.height,image.width),np.float32)
                for idx,score in detections[q]:p=np.maximum(p,masks[idx]*score)
                out[q]=p
        return out,{'language_queries':len(texts),'sam_boxes':len(allboxes),'truncated_boxes':truncated}

def main():
    p=argparse.ArgumentParser();p.add_argument('--model',choices=['clipseg','groundedsam'],required=True)
    p.add_argument('--shard',type=int,default=0);p.add_argument('--shards',type=int,default=1)
    p.add_argument('--pilot',action='store_true');p.add_argument('--limit',type=int,default=0)
    args=p.parse_args();print('IMPORT_START',vars(args),flush=True)
    import torch,transformers
    torch.set_num_threads(4);torch.manual_seed(20260906);np.random.seed(20260906)
    assert torch.cuda.is_available(),'GPU required: submit with Slurm'
    records=[json.loads(x) for x in (ROOT/'data/manifest.jsonl').read_text().splitlines()]
    if args.pilot:
        # Infrastructure / implementation checks see fit examples only.
        records=[r for r in records if r['split']=='fit']
        records=[r for r in records if (r['domain']=='controlled' and r['scene_id']=='s11_0000') or r['domain']=='natural']
    groups=collections.defaultdict(list)
    for r in records:groups[r['image_path']].append(r)
    selected=sorted(groups)
    if args.pilot:selected=selected[:1]+[x for x in selected if '/natural/' in x][:3]
    elif args.limit:selected=selected[:args.limit]
    selected=selected[args.shard::args.shards]
    suffix=f'{args.model}_{"pilot" if args.pilot else "main"}_{args.shard}of{args.shards}'
    cache=ROOT/'cache'/args.model;cache.mkdir(parents=True,exist_ok=True)
    resultfile=ROOT/'results'/f'{suffix}.jsonl';timingfile=ROOT/'results'/f'{suffix}_timings.jsonl'
    engine=ClipSeg() if args.model=='clipseg' else GroundedSam()
    print('MODEL_READY',torch.cuda.get_device_name(0),'images',len(selected),flush=True)
    started=time.time();nrecord=0;queries=0;gpu_seconds=0;hits=0
    with resultfile.open('w') as result,timingfile.open('w') as timing:
        for index,ipath in enumerate(selected):
            group=groups[ipath];texts=[]
            for r in group:
                _,qs=query_plan(r['query']);texts.extend(qs)
            texts=list(dict.fromkeys(texts));image=Image.open(ROOT/ipath).convert('RGB')
            digest=hashlib.sha256((ipath+'\n'+'\n'.join(texts)).encode()).hexdigest()[:24];cp=cache/(digest+'.npz')
            elapsed=0.;stats={'language_queries':0,'sam_boxes':0,'truncated_boxes':0}
            if cp.exists():
                z=np.load(cp);assert z['texts'].tolist()==texts;maps={q:z[f'p{i}'].astype(np.float32) for i,q in enumerate(texts)};hits+=1
            else:
                torch.cuda.synchronize();t0=time.perf_counter();maps,stats=engine.predict(image,texts);torch.cuda.synchronize();elapsed=time.perf_counter()-t0
                # Quantize identically before both scoring and storage, so replay
                # and initial evaluation see exactly the same cached scores.
                maps={q:maps[q].astype(np.float16).astype(np.float32) for q in texts}
                assert all(np.isfinite(v).all() and v.min()>=0 and v.max()<=1 for v in maps.values())
                tmp=cp.with_suffix('.partial.npz');np.savez_compressed(tmp,texts=np.array(texts),**{f'p{i}':maps[q].astype(np.float16) for i,q in enumerate(texts)});tmp.replace(cp)
            gpu_seconds+=elapsed;queries+=stats['language_queries']
            # Ground truth is loaded only after all model predictions are fixed.
            for r in group:
                gt=np.asarray(Image.open(ROOT/r['gt_path']))>0
                oracle=np.asarray(Image.open(ROOT/r['anchor_gt_path']))>0 if 'anchor_gt_path' in r else None
                preds,flags=repaired_maps(r['query'],maps,engine.threshold,oracle_anchor=oracle)
                row={k:r[k] for k in ['id','scene_id','domain','split','mode','pair_id','endpoint','target_count','seed','template','corruption']}
                row.update(model=args.model,flags=flags,features=visual_features(maps[query_plan(r['query'])[0].original],preds['cacp'],engine.threshold),scores={m:score_mask(pred,gt) for m,pred in preds.items()},cache_path=str(cp.relative_to(ROOT)),query_count=len(query_plan(r['query'])[1]))
                result.write(json.dumps(row)+'\n');nrecord+=1
            timing.write(json.dumps(dict(image_path=ipath,records=len(group),requested_unique_queries=len(texts),cached=elapsed==0,seconds=elapsed,**stats))+'\n');result.flush();timing.flush()
            if index%20==0:print(json.dumps({'image':index+1,'of':len(selected),'records':nrecord,'new_queries':queries,'forward_seconds':round(gpu_seconds,2),'wall_seconds':round(time.time()-started,2)}),flush=True)
    meta={'status':'COMPLETE','model':args.model,'images':len(selected),'records':nrecord,'unique_queries_executed':queries,'cache_hits':hits,'forward_seconds':gpu_seconds,'wall_seconds':time.time()-started,'gpu':torch.cuda.get_device_name(0),'torch':torch.__version__,'transformers':transformers.__version__,'numpy':np.__version__,'python':platform.python_version(),'slurm_job_id':os.getenv('SLURM_JOB_ID'),'node':os.getenv('SLURMD_NODENAME'),'args':vars(args),'manifest_sha256':hashlib.sha256((ROOT/'data/manifest.jsonl').read_bytes()).hexdigest(),'code_sha256':{x:hashlib.sha256((ROOT/'code'/x).read_bytes()).hexdigest() for x in ['infer.py','repair.py']}}
    (ROOT/'results'/f'{suffix}_meta.json').write_text(json.dumps(meta,indent=2));print(json.dumps(meta,indent=2),flush=True)
if __name__=='__main__':main()