90 lines
5.6 KiB
Python
90 lines
5.6 KiB
Python
"""Preregistered array-only statistics; no dataset or model access."""
|
|
from collections import defaultdict
|
|
import numpy as np
|
|
from s2_models.objectives import relative_l2
|
|
|
|
|
|
def six_region(low,high,margin=.1):
|
|
if not np.isfinite([low,high,margin]).all() or low>high or margin<=0:raise ValueError('Invalid interval')
|
|
if high<0:return 'harmful'
|
|
if low<=0:return 'no meaningful gain' if high<margin else 'insufficient evidence'
|
|
if high<margin:return 'positive but below margin'
|
|
return 'positive, size undetermined' if low<=margin else 'meaningful gain supported'
|
|
|
|
|
|
def kendall_pairs(truth,prediction,prefix,draws=5000):
|
|
t=np.asarray(truth);p=np.asarray(prediction);n=len(t)
|
|
if n<2:return dict(value=None,reason='fewer than two eligible IDs')
|
|
rng=np.random.default_rng(np.random.SeedSequence([2026111410,int(prefix)]))
|
|
# Uniform ordered distinct pairs collapse to uniform unordered i<j pairs.
|
|
i=rng.integers(0,n,draws);j=rng.integers(0,n-1,draws);j+=j>=i
|
|
lo=np.minimum(i,j);hi=np.maximum(i,j)
|
|
st=np.sign(t[hi]-t[lo]);sp=np.sign(p[hi]-p[lo])
|
|
denominator=np.sqrt(float(np.count_nonzero(st))*float(np.count_nonzero(sp)))
|
|
if denominator==0:return dict(value=None,reason='zero tau-b denominator')
|
|
return dict(value=float(np.sum(st*sp)/denominator),reason=None)
|
|
|
|
|
|
def last_location(truth,prediction,raw_ids,coordinates_over_Rg):
|
|
t=np.asarray(truth);p=np.asarray(prediction);ids=np.asarray(raw_ids)
|
|
a=np.flatnonzero(t==t.max());b=np.flatnonzero(p==p.max())
|
|
ia=a[np.argmin(ids[a])];ib=b[np.argmin(ids[b])]
|
|
return float(np.linalg.norm(np.asarray(coordinates_over_Rg)[ia]-np.asarray(coordinates_over_Rg)[ib]))
|
|
|
|
|
|
def part_metrics(prediction,truth,counts,near_wall,raw_ids,coordinates_over_Rg,prefix):
|
|
p=np.asarray(prediction);t=np.asarray(truth)
|
|
if p.shape!=t.shape or p.ndim!=1 or not len(p) or not np.isfinite(p).all() or not np.isfinite(t).all():raise ValueError('Invalid scores')
|
|
near=np.asarray(near_wall,dtype=bool)
|
|
return dict(relative_l2=relative_l2(p,t,counts,np.ones(len(t),bool)),
|
|
near_wall=relative_l2(p,t,counts,near) if near.any() else dict(value=None,reason='empty near-wall domain'),
|
|
kendall_tau_b=kendall_pairs(t,p,prefix),
|
|
last_location=dict(value=last_location(t,p,raw_ids,coordinates_over_Rg),reason=None))
|
|
|
|
|
|
def component_values(rows,roster,arm,pool,metric='relative_l2',not_known_exposed=False,frozen_members=None):
|
|
"""Complete fixed seed blocks; exposure filters parts before component means."""
|
|
if any(type(r['exposure']['development_exposed']) is not bool for r in roster):
|
|
raise ValueError('development_exposed must be bool; UNKNOWN is a separate inventory field')
|
|
if not_known_exposed and frozen_members is None:raise ValueError('Frozen exposure membership required')
|
|
main_excluded=component_values(rows,roster,arm,pool,metric,False)[1] if not_known_exposed else {}
|
|
parts=[r for r in roster if r['included'] and (not not_known_exposed or r['case'] in frozen_members)]
|
|
grouped=defaultdict(list)
|
|
for r in parts:grouped[r['component_id']].append(r)
|
|
by_key={(r['case'],r['arm'],r['pool'],r['seed']):r for r in rows}
|
|
values={};excluded={};details={}
|
|
seeds=[0,1,2] if arm in ['N','E'] else [None]
|
|
model_pool=None if arm=='B0' else pool
|
|
for component,members in sorted(grouped.items()):
|
|
block=[];reasons=[]
|
|
for member in members:
|
|
per_seed=[]
|
|
for seed in seeds:
|
|
row=by_key.get((member['case'],arm,model_pool,seed))
|
|
value=None if row is None else row[metric]['value']
|
|
if value is None:reasons.append(dict(case=member['case'],seed=seed,reason='missing prediction/model' if row is None else row[metric]['reason']))
|
|
else:per_seed.append(value)
|
|
block.append(per_seed)
|
|
details[component]=dict(parts=len(members),nodes=sum(x['nodes'] for x in members),
|
|
fold=next(a['fold'] for a in members[0]['assignments'] if a['role']=='test'))
|
|
if component in main_excluded:excluded[component]=dict(**details[component],reasons=main_excluded[component]['reasons'],main_analysis_invalid=True)
|
|
elif reasons:excluded[component]=dict(**details[component],reasons=reasons)
|
|
else:values[component]=float(np.mean(block))
|
|
return values,excluded,details
|
|
|
|
|
|
def contrast(reference,candidate,replicates=2000,seed=2026111408):
|
|
ids=sorted(set(reference)&set(candidate))
|
|
if not ids:return dict(value=None,reason='no complete paired components',components=0)
|
|
a=np.array([reference[k] for k in ids]);b=np.array([candidate[k] for k in ids])
|
|
if a.mean()<=0:return dict(value=None,reason='zero reference mean',components=len(ids))
|
|
rng=np.random.Generator(np.random.PCG64(np.random.SeedSequence(seed)));sample=rng.integers(0,len(ids),size=(replicates,len(ids)))
|
|
aa=a[sample].mean(axis=1);bb=b[sample].mean(axis=1)
|
|
undefined=np.flatnonzero(aa<=0)
|
|
if len(undefined):return dict(value=float(1-b.mean()/a.mean()),reason='undefined bootstrap replicates; no replacement or interval',
|
|
components=len(ids),undefined_replicates=len(undefined),undefined_replicate_indices=undefined.tolist(),low=None,high=None,region=None)
|
|
boot=1-bb/aa;low,high=np.percentile(boot,[2.5,97.5],method='linear')
|
|
return dict(value=float(1-b.mean()/a.mean()),low=float(low),high=float(high),components=len(ids),component_ids=ids,
|
|
reference_mean=float(a.mean()),candidate_mean=float(b.mean()),replicates=replicates,seed=seed,undefined_replicates=0,
|
|
interval='component-only percentile95 conditional on fixed folds/models/seeds',region=six_region(low,high))
|