Files
MeltMind/tools/s2_custody_statistics.py
T

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))