Datasets:
File size: 11,543 Bytes
6e46358 | 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 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 | #!/usr/bin/env python3
"""Structured-operator retention study. Standard robust linear algebra.
All uncertainty operators are supplied to the solver; this is not shift prediction.
The protocol is written before experiments, and hashes source and assumptions.
"""
from __future__ import annotations
import csv,hashlib,json,time
from pathlib import Path
import numpy as np
HERE=Path(__file__).resolve().parent
RHO=.25;TAU=.03;RIDGE=.01
SEEDS=range(16)
CONFIGS=[(p,n,r,m,False) for p in (64,128) for n in (96,256) for r in (2,4) for m in (2,4)]
CONFIGS.append((64,96,4,16,True))
METHODS=['nominal_null_ridge','robust_projector_ridge','optimized_robust_basis_ridge','scalar_budget_nominal','no_change']
def dump(path,obj):Path(path).write_text(json.dumps(obj,indent=2,allow_nan=False))
def sha(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest()
def nullspace(a):
_,s,v=np.linalg.svd(a,full_matrices=True)
tol=max(a.shape)*np.finfo(float).eps*(s[0] if len(s) else 1.)
rank=int(np.sum(s>tol))
return v[rank:].T,rank
def orthonormal_rows(rng,r,p):
q,_=np.linalg.qr(rng.normal(size=(p,r)))
return q.T
def basis_ridge(x,y,b):
basis,rank=nullspace(b)
if not basis.shape[1]:return np.zeros(x.shape[1]),rank
z=x@basis
w=np.linalg.solve(z.T@z+len(y)*RIDGE*np.eye(z.shape[1]),z.T@y)
return basis@w,rank
def projector_ridge(x,y,b):
basis,rank=nullspace(b)
projector=basis@basis.T
k=projector@x.T@x@projector+len(y)*RIDGE*np.eye(x.shape[1])
w=projector@np.linalg.solve(k,projector@x.T@y)
return w,rank
def certificate(d,b0,bs,radius=RHO):
nominal=float(np.linalg.norm(b0@d))
directions=np.column_stack([b@d for b in bs])
u,s,vt=np.linalg.svd(directions,full_matrices=False)
sigma=float(s[0]) if len(s) else 0.
theta=radius*vt[0] if len(s) else np.zeros(len(bs))
shift=b0+sum(t*b for t,b in zip(theta,bs))
attained=float(np.linalg.norm(shift@d))
reverse_attained=float(np.linalg.norm((b0-sum(t*b for t,b in zip(theta,bs)))@d))
# The exact support for nonzero b0d is not claimed to equal this sum.
return {'nominal_norm':nominal,'uncertainty_spectral_norm':sigma,
'certified_uniform_upper_bound':nominal+radius*sigma,
'nominal_null_exact_worstcase':radius*sigma,
'top_singular_adversary_norm':max(attained,reverse_attained),
'top_singular_theta':theta.tolist()}
def problem(seed,p,n,r,m):
rng=np.random.default_rng(np.random.SeedSequence([1200000+seed,p,n,r,m]))
b0=orthonormal_rows(rng,r,p);bs=[orthonormal_rows(rng,r,p) for _ in range(m)]
stack=np.vstack([b0]+bs);basis,rank=nullspace(stack)
target=rng.normal(size=p);target/=np.linalg.norm(target)
# Fixed data-generating mixture deliberately includes a conflicting direction.
safe=basis@(basis.T@target) if basis.shape[1] else np.zeros(p)
conflict=stack.T@rng.normal(size=len(stack));conflict/=max(np.linalg.norm(conflict),1e-12)
if np.linalg.norm(safe)>1e-12:safe/=np.linalg.norm(safe)
target=safe+conflict;target/=np.linalg.norm(target)
x=rng.normal(size=(n,p));y=x@target+rng.normal(0,.1,n)
test=rng.normal(size=(1024,p));ytest=test@target+rng.normal(0,.1,1024)
# Interventions are independent from solver fitting and their labels.
theta=rng.normal(size=(64,m));theta/=np.linalg.norm(theta,axis=1)[:,None]
theta*=RHO*rng.uniform(size=(64,1))**(1/m)
return x,y,test,ytest,b0,bs,theta,rank
def compose_example():
b=np.array([[1.,0.,0.]])
a1=np.zeros((3,3));a1[0,1]=1.
a2=np.zeros((3,3));a2[1,2]=1.
d=np.array([0.,0.,1.])
first=np.vstack([b,b@a1,b@a2]);closed=np.vstack([first,b@a1@a2,b@a2@a1])
return {'b0':b.tolist(),'a1':a1.tolist(),'a2':a2.tolist(),'update':d.tolist(),
'one_step_stack_residual':float(np.linalg.norm(first@d)),
'ordered_two_step_retention_residual':float(np.linalg.norm(b@a1@a2@d)),
'reverse_order_retention_residual':float(np.linalg.norm(b@a2@a1@d)),
'one_step_rank':nullspace(first)[1],'composition_closure_rank':nullspace(closed)[1],
'interpretation':'Known observability/invariant-subspace issue: single-step kernels do not guarantee preservation under unmodeled compositions.'}
def tests():
rng=np.random.default_rng(765)
b0=orthonormal_rows(rng,3,17);bs=[orthonormal_rows(rng,3,17) for _ in range(2)]
basis,rank=nullspace(b0);d=basis@rng.normal(size=basis.shape[1]);c=certificate(d,b0,bs)
assert c['nominal_norm']<1e-12
assert abs(c['top_singular_adversary_norm']-c['nominal_null_exact_worstcase'])<1e-12
for _ in range(100):
theta=rng.normal(size=2);theta*=RHO*rng.random()/np.linalg.norm(theta)
assert np.linalg.norm((b0+sum(t*b for t,b in zip(theta,bs)))@d)<=c['certified_uniform_upper_bound']+1e-12
stack=np.vstack([b0]+bs);x=rng.normal(size=(50,17));y=rng.normal(size=50)
a,_=basis_ridge(x,y,stack);b,_=projector_ridge(x,y,stack)
assert np.max(np.abs(a-b))<1e-10
assert np.linalg.norm(stack@a)<1e-12
ex=compose_example();assert ex['one_step_stack_residual']==0 and ex['ordered_two_step_retention_residual']==1
return {'passed':5,'scope':'exact spectral adversary;100 bounded random shifts; projected/basis ridge equality; common-kernel residual; noncommuting composition counterexample'}
def boot(a,seed=326):
a=np.asarray(a,float);rng=np.random.default_rng(seed)
b=a[rng.integers(len(a),size=(4000,len(a)))].mean(1)
return {'mean':float(a.mean()),'median':float(np.median(a)),
'mean_ci95':[float(v) for v in np.quantile(b,[.025,.975])]}
def main():
out=HERE/'results';out.mkdir(exist_ok=True)
protocol={'source_sha256':sha(__file__),'status':'frozen before measurements','seed_range':list(SEEDS),
'configs_p_n_r_m_stress':CONFIGS,'rho':RHO,'tau':TAU,'ridge':RIDGE,'methods':METHODS,
'known_model':'B(theta)=B0+sum theta_l B_l; all B_l are supplied exactly; ||theta||2<=rho',
'target':'fixed equal norm mixture of common-kernel and conflicting known-operator rowspace components',
'test':'1024 fresh Gaussian inputs;16 independent seeds per config',
'claim':'standard robust linear algebra, no novelty or prediction of unknown shift directions',
'outside_model':'2rho along top singular adversary, and worst arbitrary new unit-norm operator rho*||d||',
'composition':'predeclared 3D noncommuting one-step/composed preservation counterexample',
'runtime':'solver/factorization per method timed independently; shared synthetic data generation excluded'}
dump(out/'protocol.json',protocol)
print('Frozen protocol',sha(out/'protocol.json'),flush=True)
checked=tests();rows=[];details=[];order=np.random.default_rng(1009)
for seed in SEEDS:
for p,n,r,m,stress in CONFIGS:
x,y,xt,yt,b0,bs,theta,stackrank=problem(seed,p,n,r,m)
stack=np.vstack([b0]+bs);solutions={}
for method in order.permutation(METHODS):
start=time.perf_counter()
if method=='nominal_null_ridge':d,rank=basis_ridge(x,y,b0)
elif method=='robust_projector_ridge':d,rank=projector_ridge(x,y,stack)
elif method=='optimized_robust_basis_ridge':d,rank=basis_ridge(x,y,stack)
elif method=='scalar_budget_nominal':
d,rank=basis_ridge(x,y,b0);c=certificate(d,b0,bs)
d*=min(1.,TAU/max(c['certified_uniform_upper_bound'],1e-15))
else:d=np.zeros(p);rank=stackrank
solve=time.perf_counter()-start
c=certificate(d,b0,bs);outside=certificate(d,b0,bs,2*RHO)
random_norms=[np.linalg.norm((b0+sum(t*b for t,b in zip(th,bs)))@d) for th in theta]
residual=float(np.linalg.norm(stack@d))
te=float(np.mean((xt@d-yt)**2));tr=float(np.mean((x@d-y)**2))
row={'seed':seed,'p':p,'n':n,'r':r,'uncertainty_components':m,'rank_exhaustion_stress':stress,
'method':method,'stack_rank':stackrank,'robust_nullity':p-stackrank,
'generic_minimum_support_circuit_arity':stackrank+1,
'solver_s':solve,'test_nmse':te/max(float(np.var(yt)),1e-12),'train_mse':tr,
'update_norm':float(np.linalg.norm(d)),'stack_residual':residual,
'nominal_retention_norm':c['nominal_norm'],
'uniform_retention_upper_bound':c['certified_uniform_upper_bound'],
'exact_worstcase_given_nominal_null':c['nominal_null_exact_worstcase'],
'attained_top_singular_retention':c['top_singular_adversary_norm'],
'max_64_random_shift_retention':float(max(random_norms)),
'within_tau_uniform_certificate':c['certified_uniform_upper_bound']<=TAU+1e-10,
'strict_common_kernel_preservation':residual<1e-10,
'outside_2rho_top_singular_retention':outside['top_singular_adversary_norm'],
'outside_2rho_violates_tau':outside['top_singular_adversary_norm']>TAU+1e-10,
'outside_arbitrary_new_unit_operator_worstcase':RHO*float(np.linalg.norm(d))}
rows.append(row);solutions[method]=d
details.append({**row,'update':d.tolist(),'within_radius_top_singular_theta':c['top_singular_theta']})
err=float(np.max(np.abs(solutions['robust_projector_ridge']-solutions['optimized_robust_basis_ridge'])))
assert err<1e-8
for row in rows[-len(METHODS):]:row['robust_projector_basis_max_update_difference']=err
print('Seed completed',seed,flush=True)
with (out/'rows.csv').open('w') as f:
w=csv.DictWriter(f,fieldnames=list(rows[0]));w.writeheader();w.writerows(rows)
dump(out/'details.json',details)
summary={'self_tests':checked,'source_matches_protocol':sha(__file__)==protocol['source_sha256'],
'protocol_sha256':sha(out/'protocol.json'),'main':{},'rank_exhaustion_stress':{},'by_config':{},
'maximum_projector_basis_update_difference':max(r['robust_projector_basis_max_update_difference'] for r in rows),
'composition_counterexample':compose_example()}
keys=['test_nmse','solver_s','uniform_retention_upper_bound','attained_top_singular_retention',
'max_64_random_shift_retention','within_tau_uniform_certificate','strict_common_kernel_preservation',
'outside_2rho_top_singular_retention','outside_2rho_violates_tau','outside_arbitrary_new_unit_operator_worstcase']
for stress,label in [(False,'main'),(True,'rank_exhaustion_stress')]:
for method in METHODS:
rs=[r for r in rows if r['method']==method and r['rank_exhaustion_stress']==stress]
summary[label][method]={k:boot([r[k] for r in rs]) for k in keys}
for p,n,r,m,stress in CONFIGS:
key=f'p{p}_n{n}_r{r}_m{m}';summary['by_config'][key]={}
for method in METHODS:
rs=[a for a in rows if (a['p'],a['n'],a['r'],a['uncertainty_components'],a['method'])==(p,n,r,m,method)]
summary['by_config'][key][method]={k:boot([a[k] for a in rs]) for k in keys}
dump(out/'summary.json',summary)
print('Finished',json.dumps({'main':{k:{q:v[q]['mean'] for q in ['test_nmse','within_tau_uniform_certificate','solver_s']} for k,v in summary['main'].items()},'equivalence':summary['maximum_projector_basis_update_difference']}),flush=True)
if __name__=='__main__':main()
|