| """Image-grouped R2 inference, label-isolated inference and official metrics.""" |
| from pathlib import Path |
| import argparse, json, time, os, hashlib, collections, sys, platform |
| import numpy as np |
| from PIL import Image |
| ROOT=Path(__file__).resolve().parents[1] |
| from project_paths import legacy_root;OLD=legacy_root(ROOT) |
| sys.path.insert(0,str(OLD/'code')) |
| from infer import ClipSeg,GroundedSam |
| import phase1_repair as p1 |
| from r2_repair import repair,primary_plan |
|
|
| def official_score(pred,gt,pred_nt,gt_nt=None): |
| z=p1.score_mask(pred,gt);is_nt=not gt.any() if gt_nt is None else gt_nt |
| if is_nt: |
| z['iou']=float(pred_nt);z['intersection']=0 |
| if pred_nt:z['union']=0 |
| elif pred_nt or z['union']==0:z['intersection']=0;z['iou']=0. |
| z['pred_nt']=bool(pred_nt) |
| return z |
|
|
| def main(): |
| ap=argparse.ArgumentParser();ap.add_argument('--model',required=True,choices=['clipseg','groundedsam','rela']);ap.add_argument('--manifest',default='natural_full');ap.add_argument('--shard',type=int,default=0);ap.add_argument('--shards',type=int,default=1);ap.add_argument('--limit',type=int,default=0);ap.add_argument('--frozen-only',action='store_true');ap.add_argument('--device',choices=['cpu','cuda'],default='cuda');a=ap.parse_args() |
| import torch |
| torch.set_num_threads(4);torch.manual_seed(20260906);np.random.seed(20260906) |
| def sync(): |
| if a.device=='cuda':torch.cuda.synchronize() |
| device_name=torch.cuda.get_device_name(0) if a.device=='cuda' else platform.processor()+' CPU; 4 torch threads' |
| rows=[json.loads(s) for s in (ROOT/'data'/f'{a.manifest}.jsonl').read_text().splitlines()] |
| groups=collections.defaultdict(list) |
| for r in rows:groups[r['image_path']].append(r) |
| paths=sorted(groups)[a.shard::a.shards] |
| if a.limit:paths=paths[:a.limit] |
| if a.model=='rela': |
| from rela_engine import ReLA |
| engine=ReLA(device=a.device) |
| else:engine=ClipSeg() if a.model=='clipseg' else GroundedSam() |
| name=f'{a.manifest}_{a.model}_{a.shard}of{a.shards}'+('_pilot' if a.limit else '') |
| cache=ROOT/'cache'/a.model;cache.mkdir(parents=True,exist_ok=True) |
| result=ROOT/'results'/f'{name}.jsonl';tf=ROOT/'results'/f'{name}_timings.jsonl' |
| done=set() |
| if result.exists(): |
| lines=result.read_text().splitlines() |
| parsed=[] |
| for line in lines: |
| try:parsed.append(json.loads(line)) |
| except json.JSONDecodeError:break |
| result.write_text(''.join(json.dumps(x)+'\n' for x in parsed));done={r['id'] for r in parsed} |
| tstart=time.time();processed=0;inference_s=0;newq=0 |
| print('READY',name,'images',len(paths),'device',device_name,flush=True) |
| with result.open('a') as out,tf.open('a') as timing: |
| for ix,path in enumerate(paths): |
| group=[r for r in groups[path] if r['id'] not in done] |
| if not group:continue |
| image=Image.open(ROOT/path).convert('RGB');texts=[] |
| for r in group: |
| q,plan=p1.query_plan(r['query']);texts.extend([r['query'] if a.model=='rela' else q.original] if a.frozen_only else plan) |
| texts=list(dict.fromkeys(texts));allmaps={};allnt={};allofficial={};elapsed=0.;queried=0 |
| for start in range(0,len(texts),12): |
| batch=texts[start:start+12] |
| digest=hashlib.sha256((path+'\n'+'\n'.join(batch)).encode()).hexdigest()[:24];cp=cache/(digest+'.npz') |
| if cp.exists(): |
| z=np.load(cp);assert z['texts'].tolist()==batch |
| maps={q:z[f'p{i}'].astype(np.float32) for i,q in enumerate(batch)} |
| nt={q:bool(z['nt'][i]) for i,q in enumerate(batch)} if 'nt' in z else {} |
| native_masks={q:z[f'o{i}'].astype(bool) for i,q in enumerate(batch)} if 'o0' in z else {} |
| else: |
| sync();t0=time.perf_counter();maps,stats=engine.predict(image,batch);sync();seconds=time.perf_counter()-t0 |
| elapsed+=seconds;queried+=len(batch) |
| maps={q:maps[q].astype(np.float16).astype(np.float32) for q in batch};nt=stats.get('nt',{}) |
| native_masks=stats.get('official_masks',{}) |
| assert all(np.isfinite(v).all() and 0<=v.min()<=v.max()<=1 for v in maps.values()) |
| arrays={f'p{i}':maps[q].astype(np.float16) for i,q in enumerate(batch)} |
| if nt:arrays['nt']=np.array([nt[q] for q in batch]) |
| if native_masks:arrays.update({f'o{i}':native_masks[q] for i,q in enumerate(batch)}) |
| tmp=cp.with_suffix('.partial.npz');np.savez_compressed(tmp,texts=np.array(batch),**arrays);tmp.replace(cp) |
| allmaps.update(maps);allnt.update(nt);allofficial.update(native_masks) |
| inference_s+=elapsed;newq+=queried |
| gt_cache={} |
| for r in group: |
| |
| if r['gt_path'] not in gt_cache:gt_cache[r['gt_path']]=np.asarray(Image.open(ROOT/r['gt_path']))>0 |
| gt=gt_cache[r['gt_path']];q=p1.parse_query(r['query']);original_key=r['query'] if a.model=='rela' and a.frozen_only else q.original |
| if a.frozen_only: |
| raw=allmaps[original_key]>=engine.threshold |
| preds={'frozen':raw};flags={} |
| else:preds,flags=repair(r['query'],allmaps,engine.threshold) |
| if a.model=='rela': |
| |
| |
| preds['frozen']=allmaps[original_key]>=.5 |
| nt=allnt.get(original_key,not preds['frozen'].any()) |
| scores={k:official_score(v,gt,nt if k=='frozen' else not v.any()) for k,v in preds.items()} |
| row={k:v for k,v in r.items() if k not in ('gt_path','image_path')} |
| row.update(model=a.model,flags=flags,scores=scores,query_count=len(p1.query_plan(r['query'])[1]),primary_query_count=len(primary_plan(r['query'])),features=p1.visual_features(allmaps[original_key],preds.get('safe_anchor',preds['frozen']),engine.threshold)) |
| if a.frozen_only:row.update(query_count=1,primary_query_count=1) |
| if r['domain']=='natural_full': |
| key=f"official_{r['ref_id']}" |
| if key not in gt_cache:gt_cache[key]=np.asarray(Image.open(ROOT/'data/natural/masks_official480'/f"ref_{r['ref_id']}.png"))>0 |
| ogt=gt_cache[key];oscores={} |
| for variant,pred in preds.items(): |
| opred=allofficial[original_key] if a.model=='rela' and variant=='frozen' else np.asarray(Image.fromarray(pred).resize((480,480),Image.Resampling.NEAREST)) |
| oscores[variant]=official_score(opred,ogt,nt if variant=='frozen' else not pred.any(),r['target_count']==0) |
| row['official480_scores']=oscores |
| if a.model=='rela':row['native_nt']=nt |
| out.write(json.dumps(row)+'\n');processed+=1 |
| out.flush();timing.write(json.dumps(dict(image_path=path,records=len(group),unique_queries=len(texts),queries_executed=queried,forward_seconds=elapsed))+'\n');timing.flush() |
| if ix%10==0:print(json.dumps(dict(image=ix+1,of=len(paths),records=processed,forward_seconds=inference_s,wall=time.time()-tstart)),flush=True) |
| meta=dict(status='COMPLETE',model=a.model,manifest=a.manifest,records_total=len({json.loads(s)['id'] for s in result.read_text().splitlines()}),records_this_run=processed,images=len(paths),new_queries=newq,forward_seconds=inference_s,wall_seconds=time.time()-tstart,gpu=device_name,torch=torch.__version__,python=platform.python_version(),slurm_job_id=os.getenv('SLURM_JOB_ID'),args=vars(a),manifest_sha256=hashlib.sha256((ROOT/'data'/f'{a.manifest}.jsonl').read_bytes()).hexdigest(),code_sha256={p.name:hashlib.sha256(p.read_bytes()).hexdigest() for p in (ROOT/'code').glob('*.py')}) |
| (ROOT/'results'/f'{name}_meta.json').write_text(json.dumps(meta,indent=2));print(json.dumps(meta,indent=2),flush=True) |
| if __name__=='__main__':main() |
|
|
