Datasets:
File size: 11,483 Bytes
347d9a3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | """Formal dynamic evaluation with full inventory denominators and fixed identities."""
from __future__ import annotations
import argparse,copy,gzip,hashlib,json,math,sqlite3,tempfile
from collections import defaultdict
from pathlib import Path
from .frame_score import score as demo_score
from .common import VERSION,rows,write
def safe_score(gold,prediction):
"""Bound malformed coordinates/times before invoking the tested frame scorer."""
invalid=False;p=copy.deepcopy(prediction)
if gold['task_id']=='KW_ASR':
if isinstance(p,str):
p=p.replace('’',"'").replace('‘',"'")
if p.strip()=='""':p=''
result=demo_score(gold,p)
if not gold['output']:
correct=isinstance(p,str) and not p.strip()
result['empty_correct']=correct;result['exact_match']=correct
return result
sets=[]
if isinstance(p,dict):
if gold['task_id']=='DOA_TRAJECTORY' and isinstance(p.get('tracks'),list):
sets=[t for t in p['tracks'] if isinstance(t,dict)]
elif isinstance(p.get('frames'),list):sets=[p]
maximum=max(gold['expected_times_s'])
for container in sets:
if not isinstance(container.get('frames'),list):continue
filtered=[]
for f in container['frames']:
if not isinstance(f,dict):invalid=True;continue
t=f.get('time_s')
if isinstance(t,bool) or not isinstance(t,(int,float)) or not math.isfinite(t) or not 0<=t<=maximum+1e-6:
invalid=True;continue
if f.get('active') is True:
key='doa_deg' if gold['task_id']=='DOA_TRAJECTORY' else 'distance_m' if gold['task_id']=='RANGE_TRAJECTORY' else 'xyz_m'
value=f.get(key);v=[value] if key=='distance_m' else value
if not isinstance(v,list) or any(isinstance(x,bool) or not isinstance(x,(int,float)) or not math.isfinite(x) or abs(x)>1000 for x in v):
invalid=True;continue
if key=='doa_deg' and (len(v)!=2 or not -180<=v[0]<=180 or not -90<=v[1]<=90):invalid=True;continue
filtered.append(f)
container['frames']=filtered
try:result=demo_score(gold,p)
except (ValueError,TypeError,OverflowError,IndexError,KeyError):
result=demo_score(gold,None);invalid=True
if invalid:result['format_valid']=False
return result
class Accumulator:
def __init__(self):self.values=defaultdict(float);self.case_counts=defaultdict(int)
def add(self,record):
v=self.values;v['samples']+=1;v['format_valid']+=record['format_valid']
if record.get('keyword_case') is not None:
v['reference_words']+=record['reference_words'];v['edits']+=record['edits'];v['exact_match']+=record['exact_match']
self.case_counts[record['keyword_case']]+=1
if not record['reference_words']:v['negative_samples']+=1;v['empty_correct']+=bool(record['empty_correct'])
return
v['reference_active_frames']+=record['reference_active_frames'];v['covered_frames']+=record['covered_frames']
n=record['reference_active_frames'] if record['units'].startswith('degrees') else record['covered_frames']
if n and record['mean_error'] is not None:
v['error_count']+=n;v['error_sum']+=record['mean_error']*n;v['error_square_sum']+=(record['variance_error']+record['mean_error']**2)*n
threshold='success_rate_20deg' if record['units'].startswith('degrees') else 'success_rate_0_5m'
v['successful_frames']+=record[threshold]*record['reference_active_frames'];v['missed_frames']+=record['missed_frames'];v['false_positive_frames']+=record['false_positive_frames']
v['true_positive_frames']+=record['covered_frames'];v['identity_switches']+=record.get('identity_switches_diagnostic',0)
def finish(self):
v=self.values;n=v['samples'];out=dict(samples=int(n),format_valid_fraction=v['format_valid']/max(n,1))
if self.case_counts:
refs=v['reference_words'];negs=v['negative_samples']
out.update(corpus_wer=v['edits']/refs if refs else None,reference_words=int(refs),edits=int(v['edits']),
exact_match_fraction=v['exact_match']/max(n,1),negative_samples=int(negs),negative_empty_accuracy=v['empty_correct']/negs if negs else None,
keyword_cases=dict(self.case_counts))
else:
count=v['error_count'];mean=v['error_sum']/count if count else None
out.update(reference_active_frames=int(v['reference_active_frames']),covered_frames=int(v['covered_frames']),
coverage=v['covered_frames']/max(v['reference_active_frames'],1),success_rate=v['successful_frames']/max(v['reference_active_frames'],1),
mean_error=mean,variance_error=max(0.,v['error_square_sum']/count-mean**2) if count else None,
rmse=math.sqrt(v['error_square_sum']/count) if count else None,
error_count=int(count),active_precision=v['true_positive_frames']/max(v['true_positive_frames']+v['false_positive_frames'],1),
active_recall=v['true_positive_frames']/max(v['true_positive_frames']+v['missed_frames'],1),
missed_frames=int(v['missed_frames']),false_positive_frames=int(v['false_positive_frames']),identity_switches_diagnostic=int(v['identity_switches']))
return out
def freeze_predictions(path,known,database,strict=False):
database.execute('CREATE TABLE predictions (sample_id TEXT PRIMARY KEY, output TEXT)')
bad=set();counts=defaultdict(int);digest=hashlib.sha256()
with Path(path).open('rb') as f:
for number,line in enumerate(f,1):
digest.update(line)
if not line.strip():continue
try:
r=json.loads(line);sid=r.get('sample_id');output=r.get('output')
if sid not in known:raise ValueError('Unknown sample_id')
if sid in bad:counts['duplicate_rows']+=1;continue
if database.execute('SELECT 1 FROM predictions WHERE sample_id=?',(sid,)).fetchone():
counts['duplicate_rows']+=1;bad.add(sid);database.execute('DELETE FROM predictions WHERE sample_id=?',(sid,))
if strict:raise ValueError('Duplicate sample_id')
continue
database.execute('INSERT INTO predictions VALUES (?,?)',(sid,json.dumps(output)))
except (ValueError,TypeError,AttributeError) as e:
counts['invalid_rows']+=1
if strict:raise ValueError('Invalid prediction row '+str(number)+': '+str(e)) from e
if number%2000==0:database.commit()
database.commit();counts['accepted_rows']=database.execute('SELECT COUNT(*) FROM predictions').fetchone()[0]
return dict(prediction_sha256=digest.hexdigest(),counts=dict(counts),duplicate_ids=len(bad))
def evaluate(root,predictions,output,strict=False):
root=Path(root);output=Path(output);output.mkdir(parents=True,exist_ok=True)
known={r['sample_id'] for r in rows(root/'public/test/index.jsonl')}
buckets=defaultdict(Accumulator);missing=total=0;kw_pairs={}
with tempfile.TemporaryDirectory(prefix='dish-evaluate-') as temp:
db=sqlite3.connect(str(Path(temp)/'predictions.sqlite'))
inventory=freeze_predictions(predictions,known,db,strict)
# Gold is first opened only after the prediction inventory has been frozen.
with gzip.open(output/'per_sample.jsonl.gz','wt') as per_sample:
for g in rows(root/'private/test/gold.jsonl'):
found=db.execute('SELECT output FROM predictions WHERE sample_id=?',(g['sample_id'],)).fetchone()
p=json.loads(found[0]) if found else None;missing+=found is None;total+=1
result=safe_score(g,p);record=dict(sample_id=g['sample_id'],scene_id=g['scene_id'],task_id=g['task_id'],setting=g['setting'],
branch=g['branch'],difficulty=g['difficulty'],**result)
record.update(target_human_motion=g.get('target_human_motion','unspecified'),observed_receiver_motion=g.get('observed_receiver_motion','unspecified'))
per_sample.write(json.dumps(record,allow_nan=False,separators=(',',':'))+'\n')
keys=[g['setting']+'/'+g['task_id'],g['setting']+'/'+g['task_id']+'/'+g['difficulty'],
g['setting']+'/'+g['task_id']+'/branch/'+g['branch'],g['setting']+'/'+g['task_id']+'/robots/'+str(g['num_robots']),
g['setting']+'/'+g['task_id']+'/humans/'+str(g['num_humans']),g['setting']+'/'+g['task_id']+'/rt_bin/'+str(g['rt_bin'])]
keys.append(g['setting']+'/'+g['task_id']+'/motion/target_'+g.get('target_human_motion','unspecified')+'/receiver_'+g.get('observed_receiver_motion','unspecified'))
if g['task_id']=='KW_ASR':keys.append(g['setting']+'/KW_ASR/case/'+g.get('keyword_observation_case',g['keyword_case']))
for key in keys:buckets[key].add(result)
if g['task_id']=='KW_ASR':kw_pairs.setdefault(g['query_group_id'],[]).append(dict(setting=g['setting'],wer=result['wer'],correct=result['exact_match']))
db.close()
if total!=len(known):raise ValueError('Gold/public inventory mismatch')
gains=[];accuracy_gains=[]
for values in kw_pairs.values():
edges=[r for r in values if r['setting']=='edge'];cloud=next(r for r in values if r['setting']=='cloud')
if cloud['wer'] is not None:gains.append(sum(e['wer'] for e in edges)/len(edges)-cloud['wer'])
accuracy_gains.append(float(cloud['correct'])-sum(float(e['correct']) for e in edges)/len(edges))
report=dict(scorer_version=VERSION+'.1',samples=total,missing_predictions=missing,inventory=inventory,
summary={k:v.finish() for k,v in sorted(buckets.items())},
paired_kw_asr=dict(query_groups=len(kw_pairs),positive_groups=len(gains),
mean_cloud_wer_improvement_over_mean_edge=sum(gains)/len(gains) if gains else None,
mean_cloud_exact_match_improvement_over_mean_edge=sum(accuracy_gains)/len(accuracy_gains) if accuracy_gains else None),
definitions=dict(doa='Whole-clip fixed identity matching; active-frame spherical error, mean/population variance/RMSE. Missing DOA positions count as 180 degrees.',
distance_and_world='Error statistics on covered active frames, always accompanied by all-reference-frame coverage and 0.5m success.',
kw_asr='Positive corpus WER; negative empty-string accuracy; invalid and missing outputs remain failures.',
error_statistics='Frame-pooled statistics, not averages of per-example variances.',
sampling_unit='Paired motion group/room and original source/speaker; views, questions and overlapping speech crops are correlated. No cross-task overall score.',
motion_strata='Target-human and observed-receiver motion are reported separately. Motion elsewhere in the scene does not imply either selected entity moves.'))
write(output/'metrics.json',report);print('SCORED',total,'samples;',missing,'missing',flush=True)
return report
if __name__=='__main__':
p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--predictions',type=Path,required=True);p.add_argument('--output',type=Path,required=True);p.add_argument('--strict',action='store_true')
a=p.parse_args();evaluate(a.root,a.predictions,a.output,a.strict)
|