"""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: # Labels are opened only after all image/text predictions above. 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': # Preserve the trained no-target head. Native raw mask has # no connected-component filtering in the official model. 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()