| """Independent annotation-export checks; does not call its metric functions. |
| |
| Uses explicit coincidence matrices for alpha and a separate augmenting-path |
| cardinality matcher for the headline instance counts. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| from collections import Counter |
| from itertools import combinations |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
|
|
| def reference_alpha(values, levels, squared, *, ordinal=False): |
| coincidence = np.zeros((len(levels), len(levels))) |
| pairable = [v for v in values if len(v) >= 2] |
| if len(pairable) < 2: return None |
| for ratings in pairable: |
| counts=Counter(ratings) |
| for i,a in enumerate(levels): |
| for j,b in enumerate(levels): |
| coincidence[i,j] += counts[a]*(counts[b]-(a==b))/(len(ratings)-1) |
| marginals=coincidence.sum(axis=1); n=marginals.sum() |
| expected=np.outer(marginals,marginals)-np.diag(marginals) |
| distance=np.array([[(a-b)**2 if squared else float(a!=b) for b in levels] for a in levels], dtype=float) |
| if ordinal: |
| for i in range(len(levels)): |
| for j in range(len(levels)): |
| lo,hi=sorted((i,j)) |
| distance[i,j]=(sum(marginals[lo:hi+1])-(marginals[lo]+marginals[hi])/2)**2 |
| do=(coincidence*distance).sum()/n |
| de=(expected*distance).sum()/(n*(n-1)) |
| return None if de<=0 else float(1-do/de) |
|
|
|
|
| def overlap(a,b): |
| ix=max(0,min(a[0]+a[2],b[0]+b[2])-max(a[0],b[0])) |
| iy=max(0,min(a[1]+a[3],b[1]+b[3])-max(a[1],b[1])) |
| intersection=ix*iy |
| return intersection/(a[2]*a[3]+b[2]*b[3]-intersection) |
|
|
|
|
| def maximum_pairs(a,b): |
| edges=[[j for j,y in enumerate(b) if x['use_case_id']==y['use_case_id'] and overlap(x['bbox'],y['bbox'])>=.5] for x in a] |
| owners={} |
| def visit(i,seen): |
| for j in edges[i]: |
| if j in seen: continue |
| seen.add(j) |
| if j not in owners or visit(owners[j],seen): |
| owners[j]=i |
| return True |
| return False |
| for i in range(len(a)): visit(i,set()) |
| return [(i,j) for j,i in owners.items()] |
|
|
|
|
| def equal(actual,expected): |
| assert (actual is None and expected is None) or (actual is not None and expected is not None and math.isclose(actual,expected,abs_tol=1e-11)),(actual,expected) |
|
|
|
|
| def verify(artifact_path, gold_path, iaa_path, manifest_path): |
| artifact=json.loads(artifact_path.read_text()); gold=json.loads(gold_path.read_text()); raw=json.loads(iaa_path.read_text()) |
| gold_ids={r['image_id']:{v['use_case_id'] for v in r['gold']['violations']} for r in gold} |
| categories={r['image_id']:r['category'] for r in map(json.loads,manifest_path.read_text().splitlines())} |
| prepared={} |
| for r in raw: |
| labels=r['first_pass'] |
| ratings={k:[a[k] for a in labels if not a.get('reported') and type(a.get(k)) is int and 1<=a[k]<=5] for k in ('plausibility','naturalness')} |
| usable=[a for a in labels if not a.get('reported') and bool(a['no_violation_detected']) != bool(a['violations'])] |
| sets=[{v['use_case_id'] for v in a['violations']} for a in usable] |
| pairs=list(combinations(usable,2)) |
| matches=Counter(); endpoints=Counter(); raw_matches=raw_endpoints=0 |
| for a,b in pairs: |
| m=maximum_pairs(a['violations'],b['violations']) |
| for v in a['violations']+b['violations']: endpoints[v['use_case_id']]+=1/len(pairs) |
| for i,j in m: matches[a['violations'][i]['use_case_id']]+=1/len(pairs) |
| raw_matches+=len(m);raw_endpoints+=len(a['violations'])+len(b['violations']) |
| prepared[r['image_id']]={'ratings':ratings,'sets':sets,'matches':matches,'endpoints':endpoints, |
| 'raw_matches':raw_matches,'raw_endpoints':raw_endpoints} |
| checks=0 |
| for group in artifact['groups'].values(): |
| selected=[(i,p) for i,p in prepared.items() if (group['population']=='all' or i in gold_ids) and (group['source']=='all' or categories[i]==group['source'])] |
| for row in group['rows']: |
| ids=set(c for cs in artifact['domains'].values() for c in cs) if row['kind']=='overall' else set(artifact['domains'].get(row['id'],[row['id']])) |
| qrows=[p for i,p in selected if row['kind']=='overall' or gold_ids.get(i,set())&ids] |
| for k in ('plausibility','naturalness'): |
| values=[p['ratings'][k] for p in qrows if len(p['ratings'][k])>=2] |
| q=row['quality'][k] |
| assert q['eligible']==len(values) |
| equal(q['alpha']['value'],reference_alpha(values,list(range(1,6)),True,ordinal=True)) |
| equal(q['interval_alpha']['value'],reference_alpha(values,list(range(1,6)),True)) |
| equal(q['exact']['value'],sum(len(set(v))==1 for v in values)/len(values) if values else None) |
| equal(q['within_one']['value'],sum(max(v)-min(v)<=1 for v in values)/len(values) if values else None) |
| checks+=5 |
| label_rows=[[s&ids for s in p['sets']] for _,p in selected if len(p['sets'])>=2] |
| a=dis=0 |
| for sets in label_rows: |
| comparisons=list(combinations(sets,2)) |
| for x,y in comparisons: |
| a+=len(x&y)/len(comparisons);dis+=len(x^y)/len(comparisons) |
| agreement=row['agreement'] |
| equal(agreement['exact']['value'],sum(len({tuple(sorted(s)) for s in sets})==1 for sets in label_rows)/len(label_rows) if label_rows else None) |
| equal(agreement['positive_agreement']['value'],2*a/(2*a+dis) if a or dis else None) |
| if row['kind']=='class': |
| equal(agreement['alpha']['value'],reference_alpha([[int(bool(s)) for s in sets] for sets in label_rows],[0,1],False)) |
| checks+=1 |
| matches=sum(sum(p['matches'][c] for c in ids) for _,p in selected) |
| endpoints=sum(sum(p['endpoints'][c] for c in ids) for _,p in selected) |
| equal(agreement['instance_f1']['value'],2*matches/endpoints if endpoints else None) |
| equal(agreement['support']['match_5'],matches) |
| equal(agreement['support']['box_endpoints'],endpoints) |
| assert agreement['support']['label_n']==len(label_rows) |
| checks+=6 |
| print(f"Verified {group['population']} / {group['source']}",flush=True) |
| result={'status':'passed','checks':checks,'images':len(raw),'groups':len(artifact['groups']), |
| 'source_hashes':{k:v['sha256'] for k,v in artifact['sources'].items()}, |
| 'methods':['Independent explicit coincidence matrices for ordinal/interval/nominal alpha', |
| 'Raw first-pass exact/within-one and class-set aggregation', |
| 'Independent augmenting-path instance cardinality at IoU 0.50'], |
| 'limits':['Point estimates verified; bootstrap distribution and optimal-IoU tie cases are tested separately.']} |
| print(json.dumps(result,indent=2)) |
| return result |
|
|
|
|
| if __name__=='__main__': |
| parser=argparse.ArgumentParser(description=__doc__) |
| parser.add_argument('--artifact',type=Path,required=True) |
| parser.add_argument('--gold',type=Path,required=True) |
| parser.add_argument('--iaa',type=Path,required=True) |
| parser.add_argument('--manifest',type=Path,required=True) |
| parser.add_argument('--output',type=Path) |
| a=parser.parse_args() |
| result=verify(a.artifact,a.gold,a.iaa,a.manifest) |
| if a.output: a.output.write_text(json.dumps(result,indent=2)+'\n') |
|
|
