diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/core.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/core.py new file mode 100644 index 0000000000000000000000000000000000000000..e61cfa6acdc064f80fa138239efca9330d32c8c2 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/core.py @@ -0,0 +1,36 @@ +"""Small logit residual with training-only feature normalization.""" +import numpy as np + + +def logit(probability): + p=np.clip(np.asarray(probability,np.float64),1e-7,1-1e-7) + assert p.ndim==1 + return np.log(p)-np.log1p(-p) + + +def raw_features(parent,beam=None): + base=logit(parent);columns=[base] + if beam is not None:columns.append(logit(beam)-base) + return base,np.ascontiguousarray(np.column_stack(columns),np.float64) + + +def normalize(raw,center,scale): + values=(raw-np.asarray(center)[None,:])/np.asarray(scale)[None,:] + return np.ascontiguousarray(np.column_stack([np.ones(len(raw)),values]),np.float64) + + +def sigmoid(z): + u=np.exp(-np.abs(z));return np.where(z>=0,1/(1+u),u/(1+u)) + + +def objective_gradient(weights,x,base,labels,regularization): + y=np.asarray(labels,np.float64);z=base+np.sum(x*weights[None,:],axis=1);penalty=np.ones(len(weights));penalty[0]=.01 + loss=float(np.mean(np.logaddexp(0,z)-y*z)+.5*regularization*np.sum(penalty*weights*weights)) + gradient=x.T@(sigmoid(z)-y)/len(y)+regularization*penalty*weights + return loss,gradient + + +def predict(parent,beam,state): + if len(state['center'])==1:beam=None + base,raw=raw_features(parent,beam);x=normalize(raw,state['center'],state['scale']);z=base+np.sum(x*np.asarray(state['weights'])[None,:],axis=1) + return sigmoid(z).astype(np.float32) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/export.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/export.py new file mode 100644 index 0000000000000000000000000000000000000000..705ae3aa1b07d5c829458962341ce5dd84426be2 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/export.py @@ -0,0 +1,11 @@ +"""Copy portable helpers under unique names; no data caches in the model.""" +from pathlib import Path +import hashlib,shutil +root=Path(__file__).resolve().parent;r=root.parent + + +def install(package): + package=Path(package);assert not (package/'d5_prebeam_calibration_contextual.py').exists() + files={'d5_prebeam_calibration_contextual.py':package/'d5_contextual.py','d5_contextual.py':root/'runtime.py','beam_calibration_core.py':root/'core.py','beam_calibration_frontier.py':r/'full_frontier/beam_jax.py'} + for name,source in files.items():shutil.copyfile(source,package/name) + return {name:hashlib.sha256((package/name).read_bytes()).hexdigest() for name in files} diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/fit.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/fit.py new file mode 100644 index 0000000000000000000000000000000000000000..79a2792f20611ccf66f24475aac461e3ab31be66 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/fit.py @@ -0,0 +1,104 @@ +"""Train-only small corrections, then six prespecified global validation choices.""" +import os +os.environ['OPENBLAS_NUM_THREADS']='1' +os.environ['OMP_NUM_THREADS']='1' +os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:4]) +from pathlib import Path +import hashlib,json,time +import numpy as np +from scipy.optimize import minimize +from core import raw_features,normalize,objective_gradient,predict + +root=Path(__file__).resolve().parent;r=root.parent + +def digest(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest() + +def write(path,value):Path(path).write_text(json.dumps(value,indent=2)+'\n') + +def aligned(path,ids,empty=False): + with np.load(path,allow_pickle=False) as f: + keys=f['sample_ids'];p=f['probabilities'] + assert keys.dtype==np.uint64 and keys.ndim==1 and len(np.unique(keys))==len(keys)==len(ids) + assert p.dtype==np.float32 and p.shape==keys.shape and np.isfinite(p).all() and ((p>=0)&(p<=1)).all() + order=np.argsort(keys);positions=np.searchsorted(keys[order],ids);assert (positions14400:raise TimeoutError('Training evidence incomplete') + time.sleep(2) + for path,sha in lock['source_sha256'].items():assert digest(r/path)==sha,path + assert json.loads((root/'control_cpu.json').read_text())['status']=='passed' + output=root/'fit1';output.mkdir(exist_ok=False);train=Path('/workspace/data/train');validation=Path('/workspace/data/validation') + train_rows={x['name']:x for x in json.loads((train/'manifest.json').read_text())['conditions']} + val_rows={x['name']:x for x in json.loads((validation/'manifest.json').read_text())['conditions']} + generation={k:json.loads((root/k/'provenance.json').read_text()) for k in ['beam_training','parent_training']} + reference=plan['reference'];package=Path(reference['current']['package']) + for filename,key in [('model_manifest.json','parent_manifest_sha256'),('model_config.json','parent_config_sha256'),('training_provenance.json','parent_provenance_sha256')]:assert digest(package/filename)==reference[key] + assert digest(r/'full_frontier/beam_lookahead.py')==plan['training_beam_source_sha256'] + data={};audit=[] + # Validate every ID and file before any hardware-label member is opened here. + for name in plan['conditions']: + row=train_rows[name];path=train/row['arrays'];assert digest(path)==row['arrays_sha256'] + with np.load(path,allow_pickle=False) as f:ids=f['sample_ids'] + assert len(ids)==19880 and len(np.unique(ids))==len(ids) + arrays={};files={} + for kind in generation: + record=next(z for z in generation[kind]['records'] if z['condition']==name);cache=root/kind/(name+'.npz') + assert record['arrays_sha256']==row['arrays_sha256'] and record['shots']==len(ids) + assert digest(cache)==record['output_sha256'];files[kind]=record['output_sha256'] + arrays[kind]=aligned(cache,ids,empty=kind=='beam_training') + parent=arrays['parent_training'][0];beam,empty=arrays['beam_training'];beam[empty]=parent[empty] + data[name]={'ids':ids,'parent':parent,'beam':beam} + audit.append({'condition':name,'shots':len(ids),'all_ids_exact_by_value':True,'arrays_sha256':row['arrays_sha256'],'cache_sha256':files,'empty_fallbacks':int(empty.sum())}) + write(output/'training_evidence_audit.json',{'status':'passed','conditions':audit,'training_rows':sum(len(z['ids']) for z in data.values()),'label_members_opened':False,'test_data_used':False}) + initial={basis:np.random.default_rng(seed).normal(0,.001,3) for basis,seed in plan['initial_seeds'].items()} + np.savez(output/'initial_weights.npz',**initial) + # All optimization and normalization are complete before validation labels. + fits=[] + for arm in plan['arms']: + for lam in plan['regularization']: + name=f'{arm}_lambda{lam:g}';folder=output/name;folder.mkdir();conditions=[] + for condition in plan['conditions']: + row=train_rows[condition];d=data[condition] + with np.load(train/row['arrays'],allow_pickle=False) as f: + assert np.array_equal(f['sample_ids'],d['ids']);y=f['labels'].astype(np.float64) + assert y.shape==d['ids'].shape and np.isin(y,[0,1]).all() + base,raw=raw_features(d['parent'],None if arm=='parent_only' else d['beam']);center=raw.mean(axis=0);scale=np.maximum(raw.std(axis=0),.05);x=normalize(raw,center,scale) + w0=initial[row['basis']][:x.shape[1]].copy();initial_loss=objective_gradient(w0,x,base,y,lam)[0] + result=minimize(objective_gradient,w0,args=(x,base,y,lam),method='L-BFGS-B',jac=True,options={'maxiter':500,'gtol':1e-8,'ftol':1e-12}) + assert result.success and np.isfinite(result.x).all(),str(result) + state={'condition':condition,'arm':arm,'regularization':lam,'center':center.tolist(),'scale':scale.tolist(),'weights':result.x.tolist()};write(folder/(condition+'.json'),state) + q=predict(d['parent'],d['beam'],state);qc=np.clip(q.astype(float),1e-7,1-1e-7) + conditions.append({'condition':condition,'shots':len(y),'initial_weights':w0.tolist(),'initial_objective':initial_loss,'final_objective':float(result.fun),'optimizer_iterations':int(result.nit),'function_evaluations':int(result.nfev),'optimizer_message':str(result.message),'gradient_max_abs':float(np.abs(result.jac).max()),'training_failure':float(((q>=.5)!=y).mean()),'training_nll':float((-y*np.log(qc)-(1-y)*np.log1p(-qc)).mean()),'state':state}) + fits.append({'name':name,'arm':arm,'regularization':lam,'conditions':conditions}) + write(output/'training.json',{'status':'complete','declared_plan':plan,'fits':fits,'initial_weights_sha256':digest(output/'initial_weights.npz'),'selection_data_opened':False,'source_lock':lock,'test_data_used':False}) + # Existing validation beams were generated before their labels; they have no empty cases. + validation_report=json.loads((r/'full_frontier/r3_assessment1/report.json').read_text());val={} + for condition in plan['conditions']: + row=val_rows[condition];path=validation/row['arrays'];assert digest(path)==row['arrays_sha256'] + with np.load(path,allow_pickle=False) as f:ids=f['sample_ids'];y=f['labels'].astype(np.float64) + assert len(ids)==5120 and len(np.unique(ids))==len(ids) and y.shape==ids.shape and np.isin(y,[0,1]).all() + beam_path=r/'full_frontier/r3_assessment1/beam_predictions'/(condition+'.npz');record=next(z for z in validation_report['generation'] if z['condition']==condition) + assert digest(beam_path)==record['prediction_sha256'] and record['empty_fallbacks']==0 + beam,_=aligned(beam_path,ids);parent,_=aligned(Path(reference['current']['predictions'])/(condition+'.npz'),ids) + val[condition]={'ids':ids,'y':y,'parent':parent,'beam':beam} + assessments=[] + for fit in fits: + conditions=[];folder=output/fit['name']/'validation_predictions';folder.mkdir();variance=0. + for item in fit['conditions']: + condition=item['condition'];d=val[condition];q=predict(d['parent'],d['beam'],item['state']);y=d['y'];old=(d['parent']>=.5)!=y;new=(q>=.5)!=y;diff=old.astype(int)-new.astype(int);qc=np.clip(q.astype(float),1e-7,1-1e-7) + np.savez(folder/(condition+'.npz'),sample_ids=d['ids'],probabilities=q) + gain=float(diff.mean()/52);variance+=float(diff.var(ddof=1)/len(y)/52**2) + conditions.append({'condition':condition,'failure':float(new.mean()),'parent_failure':float(old.mean()),'nll':float((-y*np.log(qc)-(1-y)*np.log1p(-qc)).mean()),'corrected':int((old&~new).sum()),'introduced':int((~old&new).sum()),'P_gain':gain}) + gain=sum(z['P_gain'] for z in conditions);assessments.append({'name':fit['name'],'arm':fit['arm'],'regularization':fit['regularization'],'conditions':conditions,'net_corrected':sum(z['corrected']-z['introduced'] for z in conditions),'P_gain':gain,'expected_full_P':reference['current']['P']+gain,'paired_naive_P_standard_error':variance**.5}) + # Fixed ordering resolves exact ties; no basis-specific selection. + best=max(assessments,key=lambda x:x['expected_full_P']) + report={'status':'complete','assessments':assessments,'selected':best if best['P_gain']>0 else None,'reference_P':reference['current']['P'],'seconds':time.time()-started,'scope':'Six prespecified global choices across both d5r3 conditions, all other128 retained. Expected score only, no actual exported replay or publication yet. Standard errors omit selection and shot dependence. Compare then-current incumbent before any publication.','test_data_used':False} + write(output/'report.json',report);print(json.dumps(report,indent=2),flush=True) + +if __name__=='__main__':main() diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_beam_training.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_beam_training.py new file mode 100644 index 0000000000000000000000000000000000000000..d1cbfa570d7896c46d95684b1402fd032340eacd --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_beam_training.py @@ -0,0 +1,34 @@ +"""CPU fullbeam training evidence, with no hardware logical-label access.""" +import os +os.environ['OPENBLAS_NUM_THREADS']='1';os.environ['OMP_NUM_THREADS']='1' +available=sorted(os.sched_getaffinity(0));os.sched_setaffinity(0,available[4:20] if len(available)>=20 else available[:16]) +from pathlib import Path +import hashlib,json,multiprocessing,sys,time +import numpy as np +root=Path(__file__).resolve().parent;r=root.parent;sys.path.insert(0,str(r/'full_frontier')) +from beam_lookahead import prepare_lookahead,decode +PLAN=None;LOOK=None + +def initialize(path): + global PLAN,LOOK + with np.load(path,allow_pickle=False) as f:PLAN={k:f[k] for k in f.files} + LOOK=prepare_lookahead(PLAN) + +def work(ds): + q,report=decode(PLAN,ds,per_sector=512,lookahead=LOOK) + return float(q),report['status']=='empty_beam' + +def main(): + declared=json.loads((root/'plan.json').read_text());out=root/'beam_training';out.mkdir(exist_ok=False);records=[];rows=[z for z in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if z['distance']==5 and z['rounds']==3];started=time.time() + for row in rows: + with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:ids=f['sample_ids'];packed=f['detectors'] + ds=np.unpackbits(packed,axis=1,count=row['num_detectors'],bitorder='little');values=[];flags=[];begin=time.time();context=multiprocessing.get_context('spawn');path=r/'full_frontier/plans'/(row['name']+'.npz') + with context.Pool(16,initializer=initialize,initargs=(path,)) as pool: + for index,(q,empty) in enumerate(pool.imap(work,ds,chunksize=8),start=1): + values.append(q);flags.append(empty) + if index%1024==0:print(json.dumps({'condition':row['name'],'completed':index,'total':len(ids),'seconds':time.time()-begin}),flush=True) + q=np.asarray(values,np.float32);empty=np.asarray(flags,bool);assert np.isfinite(q).all() and ((q>=0)&(q<=1)).all();output=out/(row['name']+'.npz');np.savez(output,sample_ids=ids,probabilities=q,empty=empty) + records.append({'condition':row['name'],'shots':len(ids),'empty_count':int(empty.sum()),'seconds':time.time()-begin,'output_sha256':hashlib.sha256(output.read_bytes()).hexdigest(),'arrays_sha256':row['arrays_sha256'],'schedule_sha256':hashlib.sha256(path.read_bytes()).hexdigest()}) + report={'status':'complete','records':records,'seconds':time.time()-started,'scope':'All39760 supplied d5r3training syndromes, K512float64beam/float32savedprobabilities. No hardware logical-label member read. Empty flags saved for fallback to frozen parent in fitting/runtime. No model fitting or GPUwork.','test_data_used':False,'source_sha256':{str(p.relative_to(r)):hashlib.sha256(p.read_bytes()).hexdigest() for p in [Path(__file__).resolve(),r/'full_frontier/beam_lookahead.py']}};(out/'provenance.json').write_text(json.dumps(report,indent=2)+'\n') + +if __name__=='__main__':main() diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_parent_training.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_parent_training.py new file mode 100644 index 0000000000000000000000000000000000000000..8d3e7a2e2be55cb2da9d4e07fe1eeb7cfdf43545 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/generate_parent_training.py @@ -0,0 +1,21 @@ +"""Frozen own-parent probabilities using cached physical priors; labels unopened.""" +import os +os.environ['JAX_PLATFORMS']='cpu';os.environ['OPENBLAS_NUM_THREADS']='1';os.environ['OMP_NUM_THREADS']='4' +os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:4]) +from pathlib import Path +import hashlib,json,sys,time +import numpy as np +root=Path(__file__).resolve().parent;r=root.parent;reference=json.loads((r/'beam_r3/reference.json').read_text());package=Path(reference['current']['package']);config=json.loads((package/'model_config.json').read_text());sys.path.insert(0,str(package)) +from d5_contextual import NeuralD5Decoder +out=root/'parent_training';out.mkdir(exist_ok=False);decoder=NeuralD5Decoder();records=[];started=time.time() +for row in [x for x in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if x['distance']==5 and x['rounds']==3]: + settings=config['neural_d5'][row['group']];passes=settings['prior_pass'];cache=r/('learned_d5/full_training_priors3' if passes==3 else 'full_prior5/cache1')/(row['name']+'.npz') + with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:ids=f['sample_ids'];packed=f['detectors'] + with np.load(cache,allow_pickle=False) as f:assert np.array_equal(f['sample_ids'],ids) and np.array_equal(f['indices'],np.arange(len(ids)));prior=f[f'priors{passes}'] + parts=[];begin=time.time() + for start in range(0,len(ids),128): + parts.append(decoder.predict(package,config['conditions'][row['name']],settings,packed[start:start+128],row['num_detectors'],batch=128,initial_priors=prior[start:start+128])) + if start//128%16==0:print(json.dumps({'condition':row['name'],'completed':min(start+128,len(ids)),'total':len(ids),'seconds':time.time()-begin}),flush=True) + q=np.concatenate(parts).astype(np.float32);assert np.isfinite(q).all() and ((q>=0)&(q<=1)).all();path=out/(row['name']+'.npz');np.savez(path,sample_ids=ids,probabilities=q) + records.append({'condition':row['name'],'shots':len(ids),'prior_pass':passes,'arrays_sha256':row['arrays_sha256'],'prior_cache_sha256':hashlib.sha256(cache.read_bytes()).hexdigest(),'output_sha256':hashlib.sha256(path.read_bytes()).hexdigest(),'seconds':time.time()-begin}) +report={'status':'complete','reference':reference,'records':records,'seconds':time.time()-started,'scope':'All39760 supplied d5r3training syndromes with ownfrozenr3publication; cachedphysicalpriors allIDschecked, no labelmembers opened. CPUbatch128, no optimizerupdates.','test_data_used':False,'source_sha256':hashlib.sha256(Path(__file__).read_bytes()).hexdigest()};(out/'provenance.json').write_text(json.dumps(report,indent=2)+'\n') diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/package.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/package.py new file mode 100644 index 0000000000000000000000000000000000000000..33d0f2854d19bcceb7d6ede461e76c9a23d51709 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/package.py @@ -0,0 +1,55 @@ +"""Assemble the selected global r3 correction on the then-current incumbent.""" +from pathlib import Path +import hashlib,json,shutil +from export import install +root=Path(__file__).resolve().parent;r=root.parent + +def digest(path):return hashlib.sha256(Path(path).read_bytes()).hexdigest() + +def assemble(): + plan=json.loads((root/'plan.json').read_text());report=json.loads((root/'fit1/report.json').read_text());selected=report['selected'];assert selected is not None + reference=plan['reference'];reference_package=Path(reference['current']['package']);reference_config=json.loads((reference_package/'model_config.json').read_text()) + current=json.loads((r/'CURRENT.json').read_text());score=json.loads(Path(current['score']).read_text());out=r/'context_upgrades/beam_calibration1';out.mkdir(exist_ok=False);package=out/'package';predictions=out/'predictions' + shutil.copytree(current['package'],package);shutil.copytree(current['predictions'],predictions);config=json.loads((package/'model_config.json').read_text());folder=root/'fit1'/selected['name'];new_files=set();parent_copies={};history=[] + rows={z['name']:z for z in json.loads(Path('/workspace/data/validation/manifest.json').read_text())['conditions']};(package/'beam_calibration').mkdir() + def parent_copy(value,basis): + if isinstance(value,dict): + result={} + for key,entry in value.items(): + if key=='weights': + relative=f'weights/beam-calibration-parent-{basis}-{len(parent_copies)}.npz';shutil.copyfile(reference_package/entry,package/relative);new_files.add(relative);parent_copies[relative]={'original_relative_path':entry,'sha256':digest(package/relative)};result[key]=relative + else:result[key]=parent_copy(entry,basis) + return result + if isinstance(value,list):return [parent_copy(x,basis) for x in value] + return value + gain=0. + for assessment in selected['conditions']: + name=assessment['condition'];row=rows[name];group=row['group'];record=config['conditions'][name] + assert not config['neural_d5'][group].get('blend_turbo',False) and group not in config.get('frozen_stack',{}) + for key in ['neural_d5_plan','plan','turbo_plan','conditional_plan']: + if key in record:assert digest(package/record[key])==digest(reference_package/reference_config['conditions'][name][key]),(name,key) + state_relative='beam_calibration/'+name+'.json';shutil.copyfile(folder/(name+'.json'),package/state_relative);new_files.add(state_relative) + option={'state':state_relative,'parent':parent_copy(reference_config['neural_d5'][group],row['basis'])} + if selected['arm']=='parent_plus_beam': + relative='beam_calibration/'+name+'.npz';shutil.copyfile(r/'beam_r3/plans'/(name+'.npz'),package/relative);new_files.add(relative);option.update(plan=relative,per_sector_states=512) + config['neural_d5'][group]['beam_calibration']={record['neural_d5_plan']:option} + shutil.copyfile(folder/'validation_predictions'/(name+'.npz'),predictions/(name+'.npz')) + incumbent=score['per_condition'][name]['errors']/score['per_condition'][name]['total'];gain+=(incumbent-assessment['failure'])/52 + history.append({'condition':name,'then_current_failure':incumbent,'candidate_failure':assessment['failure'],'global_arm':selected['arm'],'global_regularization':selected['regularization']}) + expected=current['P']+gain + assert expected>current['P']+1e-12,'Candidate no longer improves the incumbent' + runtime=install(package);training_sources=package/'training_sources/beam_calibration1';training_sources.mkdir() + for filename in ['core.py','fit.py','generate_beam_training.py','generate_parent_training.py','control_cpu.py','runtime_control.py','runtime.py','export.py','package.py','after_resource.py','plan.json','FIT_SOURCE_LOCK.json','PACKAGE_SOURCE_LOCK.json']: + shutil.copyfile(root/filename,training_sources/filename) + for filename in ['beam_lookahead.py','beam_cpu.py']:shutil.copyfile(r/'full_frontier'/filename,training_sources/filename) + config['architecture']='Contextual exact d3 and d5 decoders with a selected train-fitted r3 logit correction' + (package/'model_config.json').write_text(json.dumps(config,indent=2)+'\n') + provenance=json.loads((package/'training_provenance.json').read_text());provenance['beam_calibration1']={'declared_plan':plan,'training':json.loads((root/'fit1/training.json').read_text()),'training_evidence_audit':json.loads((root/'fit1/training_evidence_audit.json').read_text()),'evidence_generation':{kind:json.loads((root/kind/'provenance.json').read_text()) for kind in ['beam_training','parent_training']},'six_global_selection_results':report,'then_current_selection':history,'frozen_parent_weight_copies':parent_copies,'runtime_export_sha256':runtime,'controls':{name:json.loads((root/name).read_text()) for name in ['control_cpu.json','runtime_control_cpu.json','runtime_control_gpu.json']},'test_data_used':False} + provenance['previous_package_validation']=provenance.pop('package_validation');(package/'training_provenance.json').write_text(json.dumps(provenance,indent=2)+'\n') + with (package/'README.md').open('a') as f:f.write('\nThe selected d5 three-round correction fits a small regularized logit model on all39,760 corresponding training shots. Parent-only and parent-plus-full-DEM-beam arms were compared with three fixed regularization values globally across both bases. The parent networks are frozen session-trained models. Feature normalization uses training only, and sample IDs never enter the model. Inference computes all evidence from input syndromes and packaged geometry; no cached predictions are packaged.\n') + manifest=json.loads((package/'model_manifest.json').read_text());paths={z['path'] for z in manifest['checkpoints']}|new_files + manifest['checkpoints']=[{'path':p,'sha256':digest(package/p),'format':'npz' if p.endswith('.npz') else 'json' if p.endswith('.json') else 'stim-dem'} for p in sorted(paths)];(package/'model_manifest.json').write_text(json.dumps(manifest,indent=2)+'\n') + candidate={'package':str(package),'predictions':str(predictions),'score':str(out/'score.json'),'expected_P':expected,'selection':history,'validation_metadata':{'prediction_generation':'Two cached calibration predictions replace the corresponding incumbent conditions; all26d5 actual replay required before publication.','runtime_evidence':'Full actual d5 replay and workload projection remain required; optional beam adds inference cost.'}} + (out/'candidate.json').write_text(json.dumps(candidate,indent=2)+'\n');print(json.dumps(candidate,indent=2),flush=True) + +if __name__=='__main__':assemble() diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/plan.json b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/plan.json new file mode 100644 index 0000000000000000000000000000000000000000..8276d246d48a39ce833d6802fd8bf365a51b5b95 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/plan.json @@ -0,0 +1,91 @@ +{ + "name": "beam_calibration1", + "status": "Declared before fitting; training evidence caches starting CPUonly", + "created_utc": "2026-10-21T20:21:49.646611+00:00", + "hypothesis": "The fullDEM beam supplies complementary probabilities but raw/equalr3globalchoices failed. Fit a small train-only correction; matchedparent-only arm identifies whether beam is needed. No accuracy improvement claimed.", + "reference": { + "current": { + "package": "/run-state/workspace/research/context_upgrades/r3_pattern1/package", + "predictions": "/run-state/workspace/research/context_upgrades/r3_pattern1/predictions", + "score": "/run-state/workspace/research/context_upgrades/r3_pattern1/score.json", + "P": 0.76744384765625 + }, + "records": [ + { + "condition": "surface_code_bX_d5_r03_center_5_5", + "group": "d5_bX_center_5_5", + "record": { + "dem": "dems/surface_code_bX_d5_r03_center_5_5.dem", + "circuit_sha256": "1cbfca6766d1e142e35233b2cbeeb039f41aebf5179c46acbd45824d928a78a6", + "conditional_plan": "conditional_plans/surface_code_bX_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bX_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bX_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "confidence_joint": { + "weights": "weights/confidence-joint1-1024.npz" + }, + "prior_pass": 3, + "blend_turbo": false + }, + "plan_file": "plans/surface_code_bX_d5_r03_center_5_5.npz", + "plan_sha256": "cc763f0638add95aa03f2b76b5acf8dcceb470de00182d6804366e3bfa0e3f0d", + "source_schedule_sha256": "12e9b86c551a382dade82f1a1e3efe5aa26aa29edabd0e906607c2bde8b7dfc8", + "source_DEM_sha256": "b0f53a8924b9c471b5f574382d8162f5eef40e5003a85a15fcb62335a0af0e4c" + }, + { + "condition": "surface_code_bZ_d5_r03_center_5_5", + "group": "d5_bZ_center_5_5", + "record": { + "dem": "dems/surface_code_bZ_d5_r03_center_5_5.dem", + "circuit_sha256": "12b124311b84adfeeb4aa4e61b9b11707691692ee807a13cfd90ee73cf733f6c", + "conditional_plan": "conditional_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "turbo_plan": "turbo_plans/surface_code_bZ_d5_r03_center_5_5.npz", + "neural_d5_plan": "neural_d5_plans/surface_code_bZ_d5_r03_center_5_5.npz" + }, + "parent_settings": { + "weights": "weights/prior-pass1-pass5-0.npz", + "prior_pass": 5, + "blend_turbo": false, + "training_checkpoint": "prior_pass1/pass5/0" + }, + "plan_file": "plans/surface_code_bZ_d5_r03_center_5_5.npz", + "plan_sha256": "3a6746481fe2953c4b5b7615b365fccfcee538ff1b8fadc910420fb0f9ba681d", + "source_schedule_sha256": "abebe153fc07da35e24b4f5e7aa7278896c2bb632a7d094ca95bcbaa58163ed7", + "source_DEM_sha256": "ed3409474d22d849cdc7b3deb9ded28d70aeff4a53cfb4a56a0d7411f5b57f88" + } + ], + "parent_manifest_sha256": "112a3c67e31cae326474ee93b1454382c8a14cc59900ff86344113d727fe4ce0", + "parent_config_sha256": "35badea7d1c73ab42edcb1193eff22613ad6f8aa0d8281596fe2c1fd78d73925", + "parent_provenance_sha256": "953d23dedc55520b654852a848cca45c0e555be23ff433f1368c5b5de1580df8", + "scope": "Nonlearned fullDEM schedules from authorized inputs, combined only with own session-trained parent. No syndrome/label/ID rows or predictions serialized as model state.", + "test_data_used": false + }, + "training_rows": 39760, + "conditions": [ + "surface_code_bX_d5_r03_center_5_5", + "surface_code_bZ_d5_r03_center_5_5" + ], + "beam_states_per_sector": 512, + "arms": [ + "parent_only", + "parent_plus_beam" + ], + "regularization": [ + 0.0001, + 0.001, + 0.01 + ], + "initial_seeds": { + "X": 20262100, + "Z": 20262101 + }, + "initialization": "Three coefficients perbasis drawnNormal(0,.001); parent_only uses firsttwo ofsameinitialvector, parent_plus_beam allthree. Eachlambda startsfromsamebasisinitialarray. No expert weights updated.", + "features": "Base offset logit(parent). Features parentlogit and beamlogit-minus-parentlogit, bothprobabilities clipped1e-7..1-1e-7 in float64. Center/scale fit onlyontraining, scalefloor.05; prependbias. Parent_only usesbiasandparentfeature.", + "loss": "Mean logicalBCE +.5lambda sum(weights^2*[.01,1,1]); independent perbasisfits, fullbatchL-BFGS-B max500,gtol1e-8,ftol1e-12.", + "selection": "Sixglobal(arm,lambda)choices across bothd5r3conditions againstfrozenownpublishedreference, full5120validationrows each; other128conditionsretained. No perbasisarm/lambdaselection. ActualGPU/portable/fullreplay/trustedscore/relocation/runtimebudgetrequired beforepublication; comparethen-currentstrongest.", + "fallback": "Emptybeam usesfrozenparent probability before featureconstruction. Parent_onlydoesnotexecute a beam ininference.", + "test_data_used": false, + "training_beam_source_sha256": "557ea3eef701c480b90896cda3e8f69e263bc852fcce805f054a90e43d7cffe5", + "reference_sha256": "9f0bbe90c63da1d9a13a27b9ecb61b07d689c64cc41055ba2c812e5b013c2701" +} diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime.py new file mode 100644 index 0000000000000000000000000000000000000000..c9dfe4f8aea78c18d4e03b6a54532d985aa39df6 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime.py @@ -0,0 +1,37 @@ +"""Portable train-fitted logit correction, with optional full-DEM beam evidence.""" +import json +import numpy as np +from d5_prebeam_calibration_contextual import NeuralD5Decoder as PreviousDecoder +from beam_calibration_core import predict as calibrate + + +class NeuralD5Decoder(PreviousDecoder): + def __init__(self): + super().__init__();self.beam_calibration_states={};self.beam_calibration_engines={} + + def predict(self,root,record,settings,packed,num_detectors,batch=512,initial_priors=None,**kwargs): + option=settings.get('beam_calibration',{}).get(record.get('neural_d5_plan','')) + if option is None:return super().predict(root,record,settings,packed,num_detectors,batch,initial_priors=initial_priors,**kwargs) + state_path=option['state'] + if state_path not in self.beam_calibration_states: + state=json.loads((root/state_path).read_text());width=len(state['center']) + assert width in [1,2] and len(state['scale'])==width and len(state['weights'])==width+1 + assert np.isfinite(np.array(state['weights']+state['center']+state['scale'])).all() and (np.array(state['scale'])>0).all() + self.beam_calibration_states[state_path]=state + state=self.beam_calibration_states[state_path];parent_settings=option['parent'] + parent_priors=initial_priors if settings.get('prior_pass')==parent_settings.get('prior_pass') else None + parent=super().predict(root,record,parent_settings,packed,num_detectors,batch,initial_priors=parent_priors,**kwargs) + if len(state['center'])==1:return calibrate(parent,None,state) + import jax + from beam_calibration_frontier import make_decoder + path=option['plan'];states=int(option['per_sector_states']);assert states==512 + if path not in self.beam_calibration_engines: + with np.load(root/path,allow_pickle=False) as f:plan={k:f[k] for k in f.files} + assert int(plan['num_detectors'])==num_detectors and int(plan['width'])<=30 + fn=make_decoder(int(plan['width']),states);arguments=[jax.device_put(plan[k]) for k in ['probabilities','masks','measured','detector_lookup','future','active']] + self.beam_calibration_engines[path]=(fn,arguments) + fn,arguments=self.beam_calibration_engines[path];dets=np.unpackbits(packed,axis=1,count=num_detectors,bitorder='little');parts=[];flags=[] + for start in range(0,len(dets),batch): + ds=dets[start:start+batch];n=len(ds);ds=np.pad(ds,((0,batch-n),(0,0)));q,empty=fn(ds,*arguments);parts.append(np.asarray(q)[:n]);flags.append(np.asarray(empty)[:n]) + beam=np.concatenate(parts).astype(np.float32);empty=np.concatenate(flags);beam[empty]=parent[empty] + return calibrate(parent,beam,state) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime_control.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime_control.py new file mode 100644 index 0000000000000000000000000000000000000000..73c76379449d93cb58be5553dc9a1d83d4bd6dcd --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/runtime_control.py @@ -0,0 +1,42 @@ +"""Portable numerical composition with nonzero synthetic correction coefficients.""" +import os,argparse +p=argparse.ArgumentParser();p.add_argument('--device',choices=['cpu','gpu'],default='cpu');args=p.parse_args() +os.environ['JAX_PLATFORMS']='cpu' if args.device=='cpu' else 'cuda';os.environ['OPENBLAS_NUM_THREADS']='1';os.environ['OMP_NUM_THREADS']='1';os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false' +os.sched_setaffinity(0,sorted(os.sched_getaffinity(0))[:(4 if args.device=='cpu' else 22)]) +from pathlib import Path +import hashlib,importlib.util,json,shutil,sys,tempfile,time +import numpy as np +import jax +from export import install +from core import predict +root=Path(__file__).resolve().parent;r=root.parent;reference=json.loads((root/'plan.json').read_text())['reference'];package=Path(reference['current']['package']);config=json.loads((package/'model_config.json').read_text());probes=json.loads((r/'full_frontier/uncertain_r3_probes.json').read_text())['records'];numeric=json.loads((r/'full_frontier/beam_uncertain_r3_cpu.json').read_text())['records'];rows=json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'];checks=[];batch=4 if args.device=='cpu' else 512 +assert jax.default_backend()==args.device +with tempfile.TemporaryDirectory(prefix='beam-calibration-control-') as temporary: + target=Path(temporary)/'package';shutil.copytree(package,target);exported=install(target);(target/'beam_calibration').mkdir();sys.path.insert(0,str(target)) + from d5_prebeam_calibration_contextual import NeuralD5Decoder as Old + spec=importlib.util.spec_from_file_location('calibration_export_control',target/'d5_contextual.py');module=importlib.util.module_from_spec(spec);spec.loader.exec_module(module);old,new=Old(),module.NeuralD5Decoder() + for probe in probes: + row=next(x for x in rows if x['name']==probe['condition']);record=config['conditions'][row['name']];parent_settings=config['neural_d5'][row['group']];indices=np.array(probe['input_array_positions']);passes=parent_settings['prior_pass'] + with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:packed=f['detectors'][indices];ids=f['sample_ids'][indices] + assert np.array_equal(ids,np.array(probe['sample_ids'],np.uint64));prior_path=r/('learned_d5/full_training_priors3' if passes==3 else 'full_prior5/cache1')/(row['name']+'.npz') + with np.load(prior_path,allow_pickle=False) as f:assert np.array_equal(f['sample_ids'][indices],ids);prior=f[f'priors{passes}'][indices] + relative='beam_calibration/'+row['name']+'.npz';shutil.copyfile(r/'beam_r3/plans'/(row['name']+'.npz'),target/relative);expected_beam=np.array(next(z['probabilities'] for z in numeric if z['condition']==row['name'] and z['method']=='independent' and z['per_sector_states']==512),np.float32) + parent=old.predict(target,record,parent_settings,packed,row['num_detectors'],batch=batch,initial_priors=prior) + for width in [1,2]: + state={'center':[.12,-.03][:width],'scale':[2.1,.8][:width],'weights':[.03,-.09,.12][:width+1]};state_path='beam_calibration/'+row['name']+f'_width{width}.json';(target/state_path).write_text(json.dumps(state)) + option={'state':state_path,'plan':relative,'per_sector_states':512,'parent':parent_settings};settings={**parent_settings,'beam_calibration':{record['neural_d5_plan']:option}} + old_engines=set(new.beam_calibration_engines);begin=time.time();actual=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch,initial_priors=prior);seconds=time.time()-begin;expected=predict(parent,expected_beam,state);delta=float(abs(expected-actual).max());assert delta<1e-4 and ((expected>=.5)==(actual>=.5)).all() + if width==1:assert set(new.beam_calibration_engines)==old_engines and np.array_equal(expected,actual) + reverse=new.predict(target,record,settings,packed[::-1].copy(),row['num_detectors'],batch=batch,initial_priors=prior[::-1].copy());single=new.predict(target,record,settings,packed[:1],row['num_detectors'],batch=batch,initial_priors=prior[:1]);assert np.array_equal(reverse,actual[::-1]) and np.array_equal(single,actual[:1]) + live=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch);live_delta=float(abs(live-actual).max());assert live_delta<1e-4 and ((live>=.5)==(actual>=.5)).all() + checks.append({'condition':row['name'],'feature_width':width,'batch':batch,'shots':len(packed),'independent_composition_max_abs':delta,'decisions_equal':True,'order_subset_exact':True,'no_new_beam_for_parent_only':width==1,'live_cached_max_abs':live_delta,'first_call_seconds':seconds}) + with np.load(target/relative,allow_pickle=False) as f:empty_plan={k:f[k] for k in f.files} + empty_plan['probabilities']=np.zeros_like(empty_plan['probabilities']);empty_relative='beam_calibration/empty_'+row['name']+'.npz';np.savez(target/empty_relative,**empty_plan) + settings['beam_calibration'][record['neural_d5_plan']]['plan']=empty_relative;fallback=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch,initial_priors=prior);assert np.array_equal(fallback,predict(parent,parent,state));checks.append({'condition':row['name'],'forced_empty_before_feature_fallback_exact':True}) + for basis,rounds in [('X',1),('Z',25)]: + row=next(z for z in rows if z['distance']==5 and z['basis']==basis and z['rounds']==rounds);record=config['conditions'][row['name']];settings={**config['neural_d5'][row['group']],'beam_calibration':{'unused_plan':{}}} + with np.load(Path('/workspace/data/train')/row['arrays'],allow_pickle=False) as f:packed=f['detectors'][:2] + a=old.predict(target,record,config['neural_d5'][row['group']],packed,row['num_detectors'],batch=batch);b=new.predict(target,record,settings,packed,row['num_detectors'],batch=batch);assert np.array_equal(a,b);checks.append({'condition':row['name'],'retained_current_path_exact':True}) + peak=int((jax.devices()[0].memory_stats() or {}).get('peak_bytes_in_use',0));assert peak<75*1024**3 +report={'status':'passed','device':str(jax.devices()[0]),'checks':checks,'peak_gpu_bytes':peak,'scope':'Exported wrapper with specified nonzero synthetic correction coefficients; no hardware labels or fitting. Independent NumPy beam/reference-parent composition, parent-only path, order/subsets, live conditioning, forced empty-before-feature fallback and retained paths. GPU mode uses production B512.','exported_source_sha256':exported,'test_data_used':False,'source_sha256':{str(p.relative_to(r)):hashlib.sha256(p.read_bytes()).hexdigest() for p in [root/'runtime.py',root/'export.py',root/'core.py',Path(__file__).resolve(),r/'full_frontier/beam_jax.py']}} +(root/f'runtime_control_{args.device}.json').write_text(json.dumps(report,indent=2)+'\n');print(json.dumps(report,indent=2),flush=True) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/verify_during_recovery.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/verify_during_recovery.py new file mode 100644 index 0000000000000000000000000000000000000000..9b442c20a141090cd5b12cf8a0c0b1998e1d00f1 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/beam_calibration1/verify_during_recovery.py @@ -0,0 +1,21 @@ +"""Use the current idle GPU window; resume trajectory only after this marker.""" +from pathlib import Path +import hashlib,json,shutil,subprocess +root=Path(__file__).resolve().parent;r=root.parent +assert not subprocess.check_output(['nvidia-smi','--query-compute-apps=pid','--format=csv,noheader'],text=True).strip() +assert json.loads((r/'block_physical/benchmark_finished.json').read_text())['complete'] +assert not (r/'feedback_trajectory/trajectory1').exists() +for lock in ['FIT_SOURCE_LOCK.json','PACKAGE_SOURCE_LOCK.json']: + for path,digest in json.loads((root/lock).read_text())['source_sha256'].items():assert hashlib.sha256((r/path).read_bytes()).hexdigest()==digest,path +for filename in ['control_cpu.json','runtime_control_cpu.json']: + report=json.loads((root/filename).read_text());assert report['status']=='passed' + for path,digest in report['source_sha256'].items(): + source=r/path if '/' in path else root/path;assert hashlib.sha256(source.read_bytes()).hexdigest()==digest,path +current=json.loads((r/'CURRENT.json').read_text());selected=json.loads((root/'fit1/report.json').read_text())['selected'];assert selected['arm']=='parent_only' +subprocess.run(['python',str(r/'run_limited.py'),str(root/'runtime_control.py'),'--device','gpu'],check=True) +subprocess.run(['python',str(root/'package.py')],check=True);out=r/'context_upgrades/beam_calibration1';package=out/'package' +provenance=json.loads((package/'training_provenance.json').read_text());provenance['beam_calibration1']['queue_amendment']=json.loads((root/'QUEUE_AMENDMENT.json').read_text());provenance['beam_calibration1']['verification_controller_sha256']=hashlib.sha256(Path(__file__).read_bytes()).hexdigest();(package/'training_provenance.json').write_text(json.dumps(provenance,indent=2)+'\n') +for filename in ['QUEUE_AMENDMENT.json','verify_during_recovery.py']:shutil.copyfile(root/filename,package/'training_sources/beam_calibration1'/filename) +subprocess.run(['python',str(r/'verify_d5_candidate.py'),str(out)],check=True) +subprocess.run(['python',str(r/'audit_completed_candidate.py'),'--candidate',str(out),'--previous',current['predictions']],check=True) +done=json.loads((out/'finished.json').read_text());(root/'beam_calibration1_finished.json').write_text(json.dumps({'complete':True,'published':done['published'],'queue_amended':True,'test_data_used':False})+'\n') diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/exact_d3__exact.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/exact_d3__exact.py new file mode 100644 index 0000000000000000000000000000000000000000..1ae5a8eb3e91ada61a5870063470a6d3453cf0e0 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/exact_d3__exact.py @@ -0,0 +1,213 @@ +"""Exact detector-error-model contraction by bounded-frontier elimination.""" +import collections +import numpy as np +import stim + + +def parse_errors(dem): + errors = [] + for ins in dem.flattened(): + if ins.type != 'error': + continue + ds, logical = set(), 0 + for t in ins.targets_copy(): + if t.is_relative_detector_id(): + ds.symmetric_difference_update([t.val]) + elif t.is_logical_observable_id(): + assert t.val == 0 + logical ^= 1 + errors.append((ds, logical, ins.args_copy()[0])) + return errors + + +def elimination_order(dem, errors): + blocks = collections.defaultdict(list) + for d, c in dem.get_detector_coordinates().items(): + blocks[c[-1]].append(d) + pending = [ds for ds, _, _ in errors if ds] + active, used, order = set(), set(), [] + for _, block in sorted(blocks.items()): + remain = set(block) + while remain: + def score(d): + new = set().union(*(e for e in pending if d in e)) - used + return len(active | new), -sum(d in e for e in pending), d + d = min(remain, key=score) + related = [e for e in pending if d in e] + active |= set().union(*related) - used + active.discard(d) + pending = [e for e in pending if d not in e] + used.add(d) + remain.remove(d) + order.append(d) + assert sorted(order) == list(range(dem.num_detectors)) + return order + + +def make_plan(dem): + errors = parse_errors(dem) + order = elimination_order(dem, errors) + rank = {d: i for i, d in enumerate(order)} + groups = collections.defaultdict(list) + for source_index, (ds, logical, p) in enumerate(errors): + first = min(ds, key=rank.get) if ds else order[0] + groups[first].append((ds, logical, p, source_index)) + slots, probabilities, masks, measured, source_indices = {}, [], [], [], [] + width = 1 + for d in order: + related = groups[d] + needed = set().union(*(ds for ds, _, _, _ in related)) | {d} + for node in sorted(needed): + if node not in slots: + free = next(i for i in range(1, 64) if i not in slots.values()) + slots[node] = free + width = max(width, free+1) + for ds, logical, p, source_index in related: + mask = logical + for node in ds: + mask ^= 1 << slots[node] + probabilities.append(p) + masks.append(mask) + measured.append(-1) + source_indices.append(source_index) + probabilities.append(0) + masks.append(1 << slots.pop(d)) + measured.append(d) + source_indices.append(-1) + assert not slots + return {'probabilities': np.array(probabilities, np.float32), + 'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32), + 'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32), + 'source_indices': np.array(source_indices, np.int32), + 'order': np.array(order, np.int32)} + + +def make_decoder(width): + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + @jax.jit + def decode(dets, probabilities, masks, measured): + f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1) + def step(f, args): + p, mask, d = args + def error(f): + prob = p[:, None] if p.ndim else p + return (1-prob)*f + prob*f[:, indices ^ mask] + def project(f): + obs = dets[:, d].astype(jnp.int32) + dst = (indices[None, :] & ~mask) | (obs[:, None]*mask) + g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0) + return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30) + return jax.lax.cond(d < 0, error, project, f), None + f, _ = jax.lax.scan(step, f, (probabilities, masks, measured)) + return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30) + return decode + + +def make_marginals(width): + """Per-shot derivatives of log syndrome probability give all error marginals.""" + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + def log_partition(dets, probabilities, masks, measured): + f = jnp.zeros(1 << width, jnp.float32).at[0].set(1) + def step(carry, args): + f, logz = carry + p, mask, d = args + def error(carry): + f, logz = carry + return ((1-p)*f + p*f[indices ^ mask], logz) + def project(carry): + f, logz = carry + dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask) + g = f[dst] * ((indices & mask)==0) + norm = jnp.maximum(jnp.sum(g), 1e-30) + return g/norm, logz+jnp.log(norm) + return jax.lax.cond(d<0, error, project, carry), None + (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured)) + return logz + return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None))) + + +def make_marginals_fb(width, return_observable=False): + """Forward/backward contraction without generic gather-gradient scatter.""" + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + # The syndrome likelihood marginalizes the unobserved logical bit. Keep + # that bit in the forward state for its output, but omit it from histories + # and backward messages, halving the largest buffers. + backward_width=width-1 if return_observable else width + backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32) + @jax.jit + def marginals(dets, probabilities, masks, measured): + f=jnp.zeros((dets.shape[0],1<>1 if return_observable else masks + _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__data.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__data.py new file mode 100644 index 0000000000000000000000000000000000000000..c4a53919501917da89ad95a4807e26e9972b8426 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__data.py @@ -0,0 +1,73 @@ +from pathlib import Path +import json,sys +import numpy as np +import stim +sys.path.insert(0,'/workspace/research/exact_d3') +from exact import make_plan,parse_errors + + +def _attach_arrays(item,root,splits): + row=item['row'] + for split in splits: + a=np.load(root/split/row['arrays']);ds=np.unpackbits(a['detectors'],axis=1,count=row['num_detectors'],bitorder='little') + item[split+'_dets']=np.pad(ds,((0,0),(0,201-ds.shape[1]))) + item[split+'_labels']=a['labels'] + + +def load_all(max_ops=3072,splits=('train','validation')): + assert set(splits)<=set(['train','validation']) + root=Path('/workspace/data') + rows=[r for r in json.loads((root/'train/manifest.json').read_text())['conditions'] if r['distance']==3] + groups=sorted({r['group'] for r in rows});result=[] + cache=Path('/workspace/research/learned_exact')/f'feature_cache-v2-{max_ops}' + cache.mkdir(exist_ok=True) + for row in rows: + cached=cache/f"{row['name']}-{row['noise_sha256'][:12]}-{row['circuit_sha256'][:12]}.npz" + if cached.exists(): + item=dict(np.load(cached,allow_pickle=False));item['row']=row + _attach_arrays(item,root,splits);result.append(item);continue + dem=stim.DetectorErrorModel.from_file(root/'train'/row['noise']);plan=make_plan(dem) + assert int(plan['width'])<=10 + count=len(plan['masks']);assert count<=max_ops,(row['name'],count) + coords=dem.get_detector_coordinates() + circuit=stim.Circuit.from_file(root/'train'/row['circuit']) + qubit_coords=circuit.get_final_qubit_coordinates() + first_measurement=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX']) + spaces=sorted(tuple(qubit_coords[t.value][:2]) for t in first_measurement.targets_copy()) + assert len(spaces)==8 + idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()} + errors=parse_errors(dem) + context=np.full((max_ops,40),200,np.int32) + static=np.zeros((max_ops,57),np.float32) + for op,source in enumerate(plan['source_indices']): + if source<0:continue + ds,logical,p=errors[source] + t=min(int(coords[d][2]) for d in ds) if ds else 0 + for dt in range(-2,3): + for s,spatial in enumerate(spaces):context[op,(dt+2)*8+s]=idx.get((t+dt,spatial),200) + for d in ds: + c=coords[d];static[op,(int(c[2])-t+2)*8+spaces.index(tuple(c[:2]))]=1 + static[op,40]=np.log(max(p,1e-7)/(1-max(p,1e-7)))/8 + static[op,41]=logical;static[op,42]=len(ds)/4 + static[op,43]=t/25;static[op,44]=row['rounds']/25 + static[op,45]=t==0;static[op,46]=t>=row['rounds']-1 + static[op,47+groups.index(row['group'])]=1 + static[op,55]=row['basis']=='X';static[op,56]=1 + masks=np.pad(plan['masks'],(0,max_ops-count)) + measured=np.pad(plan['measured'],(0,max_ops-count),constant_values=-1) + p=np.pad(plan['probabilities'],(0,max_ops-count)) + valid=((p>0)&(measured<0)).astype(np.float32) + logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)).astype(np.float32) + item={'row':row,'context':context,'static':static,'masks':masks,'measured':measured,'base_logits':logits,'valid':valid} + grid=np.full((26,8),200,np.int32) + measurement_indices=np.full(201,208,np.int32) + for detector,c in coords.items(): + t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=detector + measurement_indices[detector]=t*8+s + item['grid']=grid;item['measurement_indices']=measurement_indices + item['counts']=np.maximum((grid!=200).sum(axis=0),1).astype(np.float32) + temporary=cached.with_suffix('.tmp.npz') + np.savez(temporary,**{k:v for k,v in item.items() if k!='row'});temporary.replace(cached) + _attach_arrays(item,root,splits) + result.append(item) + return result diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__gradient.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..a593f553a8ba67f3ff02717ba99d33c0eeb697e8 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__gradient.py @@ -0,0 +1,43 @@ +"""Differentiable conditional logical likelihood through exact DEM elimination.""" +import jax +import jax.numpy as jnp + + +def make_loss_and_grad(width): + indices=jnp.arange(1<=1 + run_config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()} + run_config['original_random_seed']=20261030 + run_config['feature_mode']='events+measurements+global_density+temporal_convolutions' + run_config['temporal_seed']=20261104 + run_config['rich_checkpoint_sha256']=hashlib.sha256(args.rich_checkpoint.read_bytes()).hexdigest() + run_config['hidden_width']=128 + run_config['logit_correction_bound']=4 + run_config['starting_checkpoint_sha256']=hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None + run_config['train_manifest_sha256']=hashlib.sha256(Path('/workspace/data/train/manifest.json').read_bytes()).hexdigest() + run_config['validation_manifest_sha256']=hashlib.sha256(Path('/workspace/data/validation/manifest.json').read_bytes()).hexdigest() + source_root=Path(__file__).resolve().parent;research=source_root.parent + snapshot=args.output/'training_source';snapshot.mkdir(exist_ok=True) + source_hashes={} + for source in [Path(__file__).resolve(),source_root/'temporal_model.py',source_root/'data.py',source_root/'gradient.py',research/'exact_d3/exact.py']: + name=str(source.relative_to(research)).replace('/','__') + shutil.copyfile(source,snapshot/name);source_hashes[name]=hashlib.sha256(source.read_bytes()).hexdigest() + run_config['training_source_sha256']=source_hashes + run_config['runtime_versions']={'jax':jax.__version__,'numpy':np.__version__,'optax':optax.__version__} + (args.output/'run_config.json').write_text(json.dumps(run_config,indent=2)+'\n') + t=time.time();dataset=load_all();print(json.dumps({'loaded':len(dataset),'seconds':time.time()-t}),flush=True) + seen=[np.zeros(len(item['train_labels']),bool) for item in dataset] + assert len({len(item['train_labels']) for item in dataset})==1, 'Matched RNG protocol assumes equal condition sizes' + parameters=({k:jnp.asarray(v) for k,v in dict(np.load(args.init_weights,allow_pickle=False)).items()} if args.init_weights else initialize_from_rich(args.rich_checkpoint,seed=20261104)) + optimizer=optax.chain(optax.clip_by_global_norm(1.),optax.adamw(learning_rate=args.learning_rate,weight_decay=1e-4)) + state=optimizer.init(parameters);exact_gradient=make_loss_and_grad(10) + rng=np.random.default_rng(args.seed);optimizer_restored=False;rng_restored=False + if args.init_weights: + optfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','optimizer-')) + if optfile.exists() and not args.reset_optimizer: + leaves,treedef=jax.tree_util.tree_flatten(state);saved=np.load(optfile,allow_pickle=False) + assert len(leaves)==len(saved.files) + state=jax.tree_util.tree_unflatten(treedef,[jnp.asarray(saved[f'arr_{i}']) for i in range(len(leaves))]);optimizer_restored=True + rngfile=args.init_weights.with_name(args.init_weights.name.replace('weights-','rng-')).with_suffix('.json') + if rngfile.exists() and not args.reset_rng:rng.bit_generator.state=json.loads(rngfile.read_text());rng_restored=True + @jax.jit + def batch_gradient(parameters,ds,ys,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts): + p,pullback=jax.vjp(lambda w:probabilities(w,ds,context,static,base_logits,valid,grid,measurement_indices,counts),parameters) + loss,pred,g=exact_gradient(ds,ys,p,masks,measured) + grads=pullback(g/len(ds))[0] + return grads,jnp.mean(loss),jnp.mean((pred>=.5)!=ys) + @jax.jit + def apply_gradient(parameters,state,grads): + changes,state=optimizer.update(grads,state,parameters) + return optax.apply_updates(parameters,changes),state,optax.global_norm(grads) + exact_decode=make_decoder(10) + @jax.jit + def infer(parameters,ds,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts): + p=probabilities(parameters,ds,context,static,base_logits,valid,grid,measurement_indices,counts) + return exact_decode(ds,p,masks,measured) + def evaluate(step): + results=[];start=time.time() + for item in dataset: + n=min(args.validation_shots,len(item['validation_labels']));pred=[] + selected=np.random.default_rng(20261028).choice(len(item['validation_labels']),n,replace=False) if args.uniform_validation else np.arange(n) + vd=item['validation_dets'][selected];vy=item['validation_labels'][selected] + for begin in range(0,n,args.validation_batch): + ds=vd[begin:begin+args.validation_batch];size=len(ds) + ds=np.pad(ds,((0,args.validation_batch-size),(0,0))) + p=np.asarray(infer(parameters,ds,*[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']]))[:size] + pred.append(p) + p=np.concatenate(pred) + pp=np.clip(p.astype(np.float64),1e-7,1-1e-7);yy=vy.astype(np.float64) + results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=vy)), + 'negative_log_likelihood':float(np.mean(-yy*np.log(pp)-(1-yy)*np.log1p(-pp))), + 'brier':float(np.mean((p-vy)**2))}) + result={'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])), + 'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])), + 'seconds':time.time()-start,'conditions':results} + (args.output/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n') + np.savez(args.output/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()}) + leaves,_=jax.tree_util.tree_flatten(state) + np.savez(args.output/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)}) + (args.output/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n') + (args.output/f'checkpoint-{step}.json').write_text(json.dumps({'step':step,'new_training_shots':step*args.batch*args.accumulate_conditions, + 'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen), + 'weights':f'weights-{step}.npz','weights_sha256':hashlib.sha256((args.output/f'weights-{step}.npz').read_bytes()).hexdigest(), + 'validation':f'validation-{step}.json','complete':True},indent=2)+'\n') + print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True) + evaluate(0) + records=[] + for step in range(1,args.steps+1): + # Both arms consume the same condition and row RNG draws. The control + # reuses the first condition; the mixed arm uses every drawn condition. + sampled_conditions=rng.integers(len(dataset),size=args.accumulate_conditions) + total_grads=None;loss=0.;error=0. + for microbatch in range(args.accumulate_conditions): + condition_index=int(sampled_conditions[0 if args.condition_policy=='same' else microbatch]) + item=dataset[condition_index] + ix=rng.integers(len(item['train_labels']),size=args.batch);seen[condition_index][ix]=True + grads,part_loss,part_error=batch_gradient(parameters,item['train_dets'][ix],item['train_labels'][ix], + *[item[k] for k in ['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts']]) + total_grads=grads if total_grads is None else jax.tree_util.tree_map(jnp.add,total_grads,grads) + loss+=part_loss/args.accumulate_conditions;error+=part_error/args.accumulate_conditions + total_grads=jax.tree_util.tree_map(lambda g:g/args.accumulate_conditions,total_grads) + parameters,state,norm=apply_gradient(parameters,state,total_grads) + if step%16==0 or step==1: + record={'step':step,'loss':float(loss),'error':float(error),'gradient_norm':float(norm),'elapsed':time.time()-t} + records.append(record);print(json.dumps(record),flush=True) + if not np.isfinite(record['loss']):raise ValueError('Nonfinite training loss') + if step%args.eval_every==0 or step==args.steps:evaluate(step) + provenance={'initialization':('Continue from this session\'s trained checkpoint' if args.init_weights else 'Continue from rich weights trained from random initialization in this session; new temporal parameters randomly initialized now'), + 'original_initialization':'Rich network random seed20261030; new 32-channel temporal network random seed20261104; rich parameters retained, new input rows Normal(0,.001)', + 'rich_starting_checkpoint':str(args.rich_checkpoint), + 'rich_checkpoint_sha256':hashlib.sha256(args.rich_checkpoint.read_bytes()).hexdigest(), + 'architecture':'Rich 128-unit MLP plus 32-channel temporal encoder: four residual kernel3 convolutions with dilations1/2/4/8 and channel normalization. Receptive field31 rounds. Encoder sees events, measurements and presence masks. Per-edge 177 input features. Output4*tanh.', + 'training':'Uniform condition sampling from all 104 d3 conditions; batch drawn from the supplied training split only', + 'training_source_sha256':source_hashes,'runtime_versions':run_config['runtime_versions'], + 'eligible_training_shots':sum(len(item['train_labels']) for item in dataset), + 'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen), + 'unique_rows_by_condition':{item['row']['name']:int(x.sum()) for item,x in zip(dataset,seen)}, + 'steps':args.steps,'batch_size':args.batch,'accumulate_conditions':args.accumulate_conditions, + 'effective_batch_size':args.batch*args.accumulate_conditions,'condition_policy':args.condition_policy, + 'training_draws':args.steps*args.batch*args.accumulate_conditions, + 'condition_sampling':'Draw one condition index per microbatch in both arms; same-condition control reuses the first index while mixed arm uses all indices. Both arms consume identical RNG draws with equal-sized condition pools.','optimizer':'AdamW, weight decay 1e-4, global gradient norm clip 1', + 'learning_rate':args.learning_rate,'sampling_seed':args.seed,'optimizer_restored':optimizer_restored,'rng_restored':rng_restored,'explicit_optimizer_reset':args.reset_optimizer,'explicit_rng_reset':args.reset_rng, + 'sampling_state_source':str(rngfile) if rng_restored else f'Fresh NumPy default_rng seed {args.seed}', + 'session_trained_starting_checkpoint':str(args.init_weights) if args.init_weights else None, + 'starting_checkpoint_sha256':hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None, + 'starting_training_provenance':json.loads((args.init_weights.parent/'provenance.json').read_text()) if args.init_weights else None, + 'loss':'Binary conditional logical likelihood computed by exact frontier elimination', + 'validation_shots_per_condition':args.validation_shots,'uniform_validation':args.uniform_validation, + 'uniform_validation_seed':20261028 if args.uniform_validation else None,'test_data_used':False,'log':records} + (args.output/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n') + + +if __name__=='__main__':main() diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__temporal_model.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__temporal_model.py new file mode 100644 index 0000000000000000000000000000000000000000..28c0a97b4469d5f6172b5c011b7e3788cd0e60a0 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/condition_same1/learned_exact__temporal_model.py @@ -0,0 +1,44 @@ +"""Long temporal context for contextual exact d3 decoding.""" +import numpy as np +import jax +import jax.numpy as jnp + + +def initialize_from_rich(path,seed=20261104,channels=32): + parameters={k:jnp.asarray(v) for k,v in dict(np.load(path,allow_pickle=False)).items()} + keys=jax.random.split(jax.random.key(seed),6) + parameters['w1']=jnp.concatenate([parameters['w1'],jax.random.normal(keys[0],(channels,parameters['w1'].shape[1]))*.001],axis=0) + parameters['temporal_in']=jax.random.normal(keys[1],(24,channels))*jnp.sqrt(2/24) + parameters['temporal_bias']=jnp.zeros(channels) + for i in range(4): + parameters[f'temporal_conv_{i}']=jax.random.normal(keys[i+2],(3,channels,channels))*jnp.sqrt(1/(3*channels)) + parameters[f'temporal_conv_bias_{i}']=jnp.zeros(channels) + return parameters + + +def probabilities(parameters,dets,context_indices,static,base_logits,valid,grid,measurement_indices,counts): + event_grid=dets[:,grid] + measurement_grid=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).astype(jnp.float32) + observed=(grid!=200).astype(jnp.float32) + frames=jnp.concatenate([event_grid.astype(jnp.float32),measurement_grid*observed[None,:,:], + jnp.broadcast_to(observed[None,:,:],event_grid.shape)],axis=-1) + temporal=jax.nn.silu(frames@parameters['temporal_in']+parameters['temporal_bias']) + for i,dilation in enumerate([1,2,4,8]): + mean=jnp.mean(temporal,axis=-1,keepdims=True) + normalized=(temporal-mean)*jax.lax.rsqrt(jnp.mean((temporal-mean)**2,axis=-1,keepdims=True)+1e-5) + value=jax.lax.conv_general_dilated(normalized,parameters[f'temporal_conv_{i}'],(1,),padding='SAME', + rhs_dilation=(dilation,),dimension_numbers=('NWC','WIO','NWC')) + temporal=temporal+jax.nn.silu(value+parameters[f'temporal_conv_bias_{i}']) + times=jnp.clip(jnp.rint(static[:,43]*25).astype(jnp.int32),0,25) + temporal_context=temporal[:,times,:] + measured=jnp.pad(measurement_grid.reshape(len(dets),208),((0,0),(0,1))) + events=dets[:,context_indices].astype(jnp.float32) + measurements=measured[:,measurement_indices[context_indices]].astype(jnp.float32) + density=jnp.sum(event_grid,axis=1)/counts[None,:] + features=jnp.concatenate([events,measurements, + jnp.broadcast_to(density[:,None,:],(len(dets),len(context_indices),8)), + jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),temporal_context],axis=-1) + h=jax.nn.silu(features@parameters['w1']+parameters['b1']) + h=jax.nn.silu(h@parameters['w2']+parameters['b2']) + delta=4*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0]) + return (jax.nn.sigmoid(base_logits[None,:]+delta)*valid[None,:]).T diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/exact_d3__exact.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/exact_d3__exact.py new file mode 100644 index 0000000000000000000000000000000000000000..1ae5a8eb3e91ada61a5870063470a6d3453cf0e0 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/exact_d3__exact.py @@ -0,0 +1,213 @@ +"""Exact detector-error-model contraction by bounded-frontier elimination.""" +import collections +import numpy as np +import stim + + +def parse_errors(dem): + errors = [] + for ins in dem.flattened(): + if ins.type != 'error': + continue + ds, logical = set(), 0 + for t in ins.targets_copy(): + if t.is_relative_detector_id(): + ds.symmetric_difference_update([t.val]) + elif t.is_logical_observable_id(): + assert t.val == 0 + logical ^= 1 + errors.append((ds, logical, ins.args_copy()[0])) + return errors + + +def elimination_order(dem, errors): + blocks = collections.defaultdict(list) + for d, c in dem.get_detector_coordinates().items(): + blocks[c[-1]].append(d) + pending = [ds for ds, _, _ in errors if ds] + active, used, order = set(), set(), [] + for _, block in sorted(blocks.items()): + remain = set(block) + while remain: + def score(d): + new = set().union(*(e for e in pending if d in e)) - used + return len(active | new), -sum(d in e for e in pending), d + d = min(remain, key=score) + related = [e for e in pending if d in e] + active |= set().union(*related) - used + active.discard(d) + pending = [e for e in pending if d not in e] + used.add(d) + remain.remove(d) + order.append(d) + assert sorted(order) == list(range(dem.num_detectors)) + return order + + +def make_plan(dem): + errors = parse_errors(dem) + order = elimination_order(dem, errors) + rank = {d: i for i, d in enumerate(order)} + groups = collections.defaultdict(list) + for source_index, (ds, logical, p) in enumerate(errors): + first = min(ds, key=rank.get) if ds else order[0] + groups[first].append((ds, logical, p, source_index)) + slots, probabilities, masks, measured, source_indices = {}, [], [], [], [] + width = 1 + for d in order: + related = groups[d] + needed = set().union(*(ds for ds, _, _, _ in related)) | {d} + for node in sorted(needed): + if node not in slots: + free = next(i for i in range(1, 64) if i not in slots.values()) + slots[node] = free + width = max(width, free+1) + for ds, logical, p, source_index in related: + mask = logical + for node in ds: + mask ^= 1 << slots[node] + probabilities.append(p) + masks.append(mask) + measured.append(-1) + source_indices.append(source_index) + probabilities.append(0) + masks.append(1 << slots.pop(d)) + measured.append(d) + source_indices.append(-1) + assert not slots + return {'probabilities': np.array(probabilities, np.float32), + 'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32), + 'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32), + 'source_indices': np.array(source_indices, np.int32), + 'order': np.array(order, np.int32)} + + +def make_decoder(width): + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + @jax.jit + def decode(dets, probabilities, masks, measured): + f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1) + def step(f, args): + p, mask, d = args + def error(f): + prob = p[:, None] if p.ndim else p + return (1-prob)*f + prob*f[:, indices ^ mask] + def project(f): + obs = dets[:, d].astype(jnp.int32) + dst = (indices[None, :] & ~mask) | (obs[:, None]*mask) + g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0) + return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30) + return jax.lax.cond(d < 0, error, project, f), None + f, _ = jax.lax.scan(step, f, (probabilities, masks, measured)) + return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30) + return decode + + +def make_marginals(width): + """Per-shot derivatives of log syndrome probability give all error marginals.""" + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + def log_partition(dets, probabilities, masks, measured): + f = jnp.zeros(1 << width, jnp.float32).at[0].set(1) + def step(carry, args): + f, logz = carry + p, mask, d = args + def error(carry): + f, logz = carry + return ((1-p)*f + p*f[indices ^ mask], logz) + def project(carry): + f, logz = carry + dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask) + g = f[dst] * ((indices & mask)==0) + norm = jnp.maximum(jnp.sum(g), 1e-30) + return g/norm, logz+jnp.log(norm) + return jax.lax.cond(d<0, error, project, carry), None + (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured)) + return logz + return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None))) + + +def make_marginals_fb(width, return_observable=False): + """Forward/backward contraction without generic gather-gradient scatter.""" + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + # The syndrome likelihood marginalizes the unobserved logical bit. Keep + # that bit in the forward state for its output, but omit it from histories + # and backward messages, halving the largest buffers. + backward_width=width-1 if return_observable else width + backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32) + @jax.jit + def marginals(dets, probabilities, masks, measured): + f=jnp.zeros((dets.shape[0],1<>1 if return_observable else masks + _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint.py new file mode 100644 index 0000000000000000000000000000000000000000..edd86a7ff804508c6566bb31150bd8e3058ddf3b --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint.py @@ -0,0 +1,38 @@ +"""Prototype confidence-aware gate; not yet a trained or queued candidate.""" +import jax.numpy as jnp +from joint_mixture import gate_features as syndrome_features +from joint_mixture import initialize_gate as initialize_base_gate +from joint_mixture import gate_logit, mixture_terms, mix_predictions + +GATE_FEATURES = 45 + + +def confidence_features(predictions): + """Four bounded shot-local features; no labels or batch statistics.""" + p = jnp.clip(predictions, 1e-6, 1-1e-6) + z = jnp.clip(jnp.log(p)-jnp.log1p(-p), -8., 8.)/8 + return jnp.concatenate([z,jnp.sqrt(z*z+1e-4)],axis=1) + + +def gate_features(dets, grid, static, predictions): + result = jnp.concatenate([syndrome_features(dets,grid,static),confidence_features(predictions)],axis=1) + assert result.shape==(len(dets),GATE_FEATURES) + return result + + +def initialize_gate(seed, hidden=32): + """Preserve the original seeded 41-input trunk; append zero new-input rows.""" + gate = initialize_base_gate(seed,hidden) + gate['w1'] = jnp.concatenate([gate['w1'],jnp.zeros((4,hidden),gate['w1'].dtype)],axis=0) + return gate + + +def expert_adjoint_factors(losses, labels, responsibility, gate_prediction_adjoint): + """Per-shot factors on expert BCE adjoints, including the confidence path. + + gate_prediction_adjoint is dL/dq through the gate only, for each per-shot + loss (not its batch mean). dq/dedge=(1-2*y)*exp(-BCE)*dBCE/dedge. + Labels enter this loss derivative only; all gate inputs use predictions. + """ + sign = 1-2*labels.astype(losses.dtype) + return responsibility+sign[:,None]*jnp.exp(-losses)*gate_prediction_adjoint diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_gradient.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..f1249ff3a5dd9e17abd5362502702556083b536c --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_gradient.py @@ -0,0 +1,43 @@ +"""Prototype complete gate/expert chain rule through confidence features.""" +import jax +import jax.numpy as jnp +from confidence_joint import gate_features, gate_logit, mixture_terms, mix_predictions, expert_adjoint_factors + + +def make_gradient(probabilities, exact_gradient): + @jax.jit + def gradient(parameters,dets,labels,base,context,static,valid,masks,measured, + grid,measurement_indices,counts): + arguments = (dets,base,context,static,valid,grid,measurement_indices,counts) + p0,pull0 = jax.vjp(lambda w:probabilities(w,*arguments),parameters['expert0']) + loss0,pred0,g0 = exact_gradient(dets,labels,p0,masks,measured) + p1,pull1 = jax.vjp(lambda w:probabilities(w,*arguments),parameters['expert1']) + loss1,pred1,g1 = exact_gradient(dets,labels,p1,masks,measured) + losses = jnp.stack([loss0,loss1],axis=1) + predictions = jnp.stack([pred0,pred1],axis=1) + logit,pull_gate = jax.vjp(lambda w,q:gate_logit(w,gate_features(dets,grid,static,q)), + parameters['gate'],predictions) + loss,responsibility,adjoint,coefficients = mixture_terms(losses,logit) + # Each gate output depends only on its own shot, so this VJP yields + # per-shot prediction adjoints and the sum of parameter gradients. + gate_sum,extra_prediction_adjoint = pull_gate(adjoint) + factors = expert_adjoint_factors(losses,labels,responsibility,extra_prediction_adjoint) + batch = len(dets) + gradients = {'expert0':pull0(g0*factors[:,0][None]/batch)[0], + 'expert1':pull1(g1*factors[:,1][None]/batch)[0], + 'gate':jax.tree_util.tree_map(lambda x:x/batch,gate_sum)} + prediction = mix_predictions(predictions,logit) + return gradients,loss.mean(),jnp.mean((prediction>=.5)!=labels),coefficients.mean(axis=0) + return gradient + + +def make_infer(probabilities,exact_decode): + @jax.jit + def infer(parameters,dets,base,context,static,valid,masks,measured, + grid,measurement_indices,counts): + arguments = (dets,base,context,static,valid,grid,measurement_indices,counts) + q = jnp.stack([exact_decode(dets,probabilities(parameters[key],*arguments),masks,measured) + for key in ['expert0','expert1']],axis=1) + logit = gate_logit(parameters['gate'],gate_features(dets,grid,static,q)) + return mix_predictions(q,logit) + return infer diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_state.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_state.py new file mode 100644 index 0000000000000000000000000000000000000000..ddc34f50ab91aaff74b10066772f23f2617a1621 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_state.py @@ -0,0 +1,83 @@ +"""Serialization and distinct Adam clocks for two experts and a new gate.""" +from pathlib import Path +import hashlib +import numpy as np +import jax +import jax.numpy as jnp +import optax +from confidence_joint import initialize_gate + +PARTS = ('expert0', 'expert1', 'gate') + + +def save_weights(path, parameters): + np.savez(path, **{part + '__' + key: np.asarray(value) + for part, values in parameters.items() for key, value in values.items()}) + + +def load_weights(path): + result = {part: {} for part in PARTS} + with np.load(path, allow_pickle=False) as saved: + for key in saved.files: + part, name = key.split('__', 1) + result[part][name] = jnp.asarray(saved[key]) + assert all(result.values()) + return result + + +def save_state(path, state): + leaves, _ = jax.tree_util.tree_flatten(state) + np.savez(path, **{f'arr_{i}': np.asarray(leaf) for i, leaf in enumerate(leaves)}) + + +def load_state(path, template): + leaves, tree = jax.tree_util.tree_flatten(template) + loaded = [] + with np.load(path, allow_pickle=False) as saved: + assert set(saved.files) == {f'arr_{i}' for i in range(len(leaves))} + for i, leaf in enumerate(leaves): + value = saved[f'arr_{i}'] + assert value.shape == leaf.shape and value.dtype == leaf.dtype + loaded.append(jnp.asarray(value)) + return jax.tree_util.tree_unflatten(tree, loaded) + + +def initialize(parent_paths, seed, expert_lr, gate_lr): + assert len(parent_paths) == 2 + parameters = {'gate': initialize_gate(seed)} + state = {} + records = [] + for i, path in enumerate(map(Path, parent_paths)): + key = f'expert{i}' + with np.load(path, allow_pickle=False) as saved: + parameters[key] = {name: jnp.asarray(saved[name]) for name in saved.files} + assert set(parameters[key]) == {'w1', 'b1', 'w2', 'b2', 'w3', 'b3'} + assert parameters[key]['w1'].shape == (394, 64) + original = optax.chain(optax.clip_by_global_norm(1), optax.adamw(expert_lr, weight_decay=1e-4)) + optimizer_path = path.with_name(path.name.replace('weights-', 'optimizer-')) + original_state = load_state(optimizer_path, original.init(parameters[key])) + state[key] = original_state[1] + records.append({'part': key, 'weights': str(path), 'weights_sha256': hashlib.sha256(path.read_bytes()).hexdigest(), + 'optimizer': str(optimizer_path), 'optimizer_sha256': hashlib.sha256(optimizer_path.read_bytes()).hexdigest(), + 'initial_adam_count': int(state[key][0].count), 'moments_restored': True}) + state['gate'] = optax.adamw(gate_lr, weight_decay=1e-4).init(parameters['gate']) + return parameters, state, records + + +def make_apply(expert_lr, gate_lr): + optimizers = {part: optax.adamw(gate_lr if part == 'gate' else expert_lr, weight_decay=1e-4) for part in PARTS} + clip = optax.clip_by_global_norm(1) + @jax.jit + def apply(parameters, state, gradients): + norm = optax.global_norm(gradients) + gradients, _ = clip.update(gradients, clip.init(parameters), parameters) + new_parameters, new_state = {}, {} + for part in PARTS: + updates, new_state[part] = optimizers[part].update(gradients[part], state[part], parameters[part]) + new_parameters[part] = optax.apply_updates(parameters[part], updates) + return new_parameters, new_state, norm + return apply + + +def counts(state): + return {part: int(state[part][0].count) for part in PARTS} diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_train.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_train.py new file mode 100644 index 0000000000000000000000000000000000000000..edc01d92926299868b536f0ad36ce13d205aa561 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__confidence_joint_train.py @@ -0,0 +1,145 @@ +"""Matched joint BCE training with syndrome and expert-confidence gate inputs.""" +import os +os.environ['OPENBLAS_NUM_THREADS'] = '1' +os.environ['OMP_NUM_THREADS'] = '1' +os.environ['XLA_PYTHON_CLIENT_PREALLOCATE'] = 'false' +from pathlib import Path +import argparse +import hashlib +import json +import shutil +import sys +import time +import numpy as np +import jax +from model import probabilities +from data import load_all +from confidence_joint_gradient import make_gradient, make_infer +from confidence_joint_state import initialize, make_apply, save_weights, load_weights, save_state, load_state, counts + +root = Path(__file__).resolve().parent +research = root.parent +sys.path.insert(0, str(research / 'learned_exact')) +from checkpoint_gradient import make_loss_and_grad +from exact import make_decoder + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument('--parents', type=Path, nargs=2, required=True) + parser.add_argument('--output', type=Path, required=True) + parser.add_argument('--training-cache', type=Path, required=True) + parser.add_argument('--resume', type=Path) + parser.add_argument('--steps', type=int, default=2048) + parser.add_argument('--batch', type=int, default=1024) + parser.add_argument('--expert-lr', type=float, default=.0001) + parser.add_argument('--gate-lr', type=float, default=.001) + parser.add_argument('--gate-seed', type=int, default=20261310) + parser.add_argument('--seed', type=int, default=20261311) + parser.add_argument('--eval-every', type=int, default=512) + parser.add_argument('--validation-shots', type=int, default=1024) + parser.add_argument('--validation-batch', type=int, default=512) + args = parser.parse_args() + args.output.mkdir(exist_ok=False) + config = {key: ([str(p) for p in value] if key == 'parents' else str(value) if isinstance(value, Path) else value) + for key, value in vars(args).items()} + source_paths = [root / name for name in ['joint_mixture.py', 'confidence_joint.py', 'confidence_joint_gradient.py', 'confidence_joint_state.py', + 'confidence_joint_train.py', 'model.py', 'data.py']] + source_paths += [research / 'learned_exact/checkpoint_gradient.py', research / 'exact_d3/exact.py'] + snapshot = args.output / 'training_source'; snapshot.mkdir() + hashes = {} + for source in source_paths: + name = str(source.relative_to(research)).replace('/', '__') + shutil.copyfile(source, snapshot / name) + hashes[name] = hashlib.sha256(source.read_bytes()).hexdigest() + parameters, state, parent_records = initialize(args.parents, args.gate_seed, args.expert_lr, args.gate_lr) + rng = np.random.default_rng(args.seed) + if args.resume: + old = json.loads((args.resume.parent / 'run_config.json').read_text()) + for key in ['parents', 'expert_lr', 'gate_lr', 'gate_seed', 'seed', 'batch', 'training_cache']: + assert old[key] == config[key], key + parameters = load_weights(args.resume) + state = load_state(args.resume.with_name(args.resume.name.replace('weights-', 'optimizer-')), state) + rng.bit_generator.state = json.loads(args.resume.with_name(args.resume.name.replace('weights-', 'rng-')).with_suffix('.json').read_text()) + config.update(training_source_sha256=hashes, parent_records=parent_records, initial_adam_counts=counts(state), + initialization='Both experts copied with exact Adam state from declared session-trained parents; new gate retains the original seeded 41-input hidden weights, appends four zero confidence-input rows, and has zero output, giving the same initial equal mixture', + sampling='Same seed and draws as syndrome-only joint_mixture1; resumed phases restore only their own saved sampling state', + runtime_versions={'jax': jax.__version__, 'numpy': np.__version__}) + (args.output / 'run_config.json').write_text(json.dumps(config, indent=2) + '\n') + started = time.time() + dataset = load_all(prior_pass=3, training_cache=args.training_cache) + assert len(dataset) == 26 + print(json.dumps({'loaded_conditions': len(dataset), 'seconds': time.time() - started}), flush=True) + seen = [np.zeros(len(item['train_labels']), bool) for item in dataset] + os.environ['XLA_PYTHON_CLIENT_PREALLOCATE'] = 'true' + os.environ['XLA_PYTHON_CLIENT_MEM_FRACTION'] = '0.90' + gradient = make_gradient(probabilities, make_loss_and_grad(14, 32)) + infer = make_infer(probabilities, make_decoder(14)) + apply = make_apply(args.expert_lr, args.gate_lr) + feature_names = ['context', 'static', 'valid', 'masks', 'measured', 'grid', 'measurement_indices', 'counts'] + + def feature_values(item): + length = ((int(item['operation_count']) + 511) // 512) * 512 + return length, [item[k][:length] for k in feature_names[:5]] + [item[k] for k in feature_names[5:]] + + def evaluate(step): + results = []; beginning = time.time() + for item in dataset: + n = min(args.validation_shots, len(item['validation_labels'])) + selected = np.random.default_rng(20261102).choice(len(item['validation_labels']), n, replace=False) + length, features = feature_values(item) + parts = [] + for begin in range(0, n, args.validation_batch): + ix = selected[begin:begin + args.validation_batch]; size = len(ix) + ds = np.pad(item['validation_dets'][ix], ((0, args.validation_batch - size), (0, 0))) + base = np.pad(item['validation_base_logits'][ix, :length], ((0, args.validation_batch - size), (0, 0))) + parts.append(np.asarray(infer(parameters, ds, base, *features))[:size]) + p = np.concatenate(parts); y = item['validation_labels'][selected].astype(np.float64) + pp = np.clip(p.astype(np.float64), 1e-7, 1 - 1e-7) + results.append({'condition': item['row']['name'], 'failure': float(np.mean((p >= .5) != y)), + 'negative_log_likelihood': float(np.mean(-y * np.log(pp) - (1 - y) * np.log1p(-pp)))}) + report = {'step': step, 'validation_failure': float(np.mean([r['failure'] for r in results])), + 'negative_log_likelihood': float(np.mean([r['negative_log_likelihood'] for r in results])), + 'conditions': results, 'seconds': time.time() - beginning} + (args.output / f'validation-{step}.json').write_text(json.dumps(report, indent=2) + '\n') + save_weights(args.output / f'weights-{step}.npz', parameters) + save_state(args.output / f'optimizer-{step}.npz', state) + (args.output / f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state) + '\n') + (args.output / f'checkpoint-{step}.json').write_text(json.dumps({ + 'step': step, 'training_draws': step * args.batch, 'adam_counts': counts(state), + 'distinct_phase_rows': sum(int(mask.sum()) for mask in seen), + 'distinct_by_condition': {item['row']['name']: int(mask.sum()) for item, mask in zip(dataset, seen)}, + 'weights_sha256': hashlib.sha256((args.output / f'weights-{step}.npz').read_bytes()).hexdigest(), 'complete': True}, indent=2) + '\n') + print(json.dumps({k: v for k, v in report.items() if k != 'conditions'}), flush=True) + + evaluate(0) + records = [] + for step in range(1, args.steps + 1): + condition = int(rng.integers(len(dataset))); item = dataset[condition] + ix = rng.integers(len(item['train_labels']), size=args.batch); seen[condition][ix] = True + length, features = feature_values(item) + gradients, loss, error, coefficients = gradient(parameters, item['train_dets'][ix], item['train_labels'][ix], + item['train_base_logits'][ix, :length], *features) + parameters, state, norm = apply(parameters, state, gradients) + if step == 1 or step % 16 == 0: + record = {'step': step, 'loss': float(loss), 'error': float(error), 'gradient_norm': float(norm), + 'mean_coefficients': np.asarray(coefficients).tolist(), 'elapsed': time.time() - started} + assert np.isfinite(record['loss']) and np.isfinite(record['gradient_norm']) + records.append(record); print(json.dumps(record), flush=True) + if step % args.eval_every == 0 or step == args.steps: + evaluate(step) + provenance = {'run_config': config, 'parent_provenance': [json.loads((p.parent / 'provenance.json').read_text()) for p in args.parents], + 'training': 'All516880 supplied d5 training rows eligible; uniform condition and row sampling with replacement', + 'training_shots': sum(len(item['train_labels']) for item in dataset), + 'distinct_phase_rows': sum(int(mask.sum()) for mask in seen), + 'loss': 'Conditional logical BCE of two trainable exact-decoder probabilities; responsibilities and the complete expert-confidence gate chain rule scale expert BCE gradients; free gate-logit adjoint is coefficient minus responsibility', + 'optimizer': 'Separate restored expert AdamW states and fresh gate AdamW; one global norm1 clipping over the full joint gradient, weight_decay1e-4; rates in run_config', + 'gate': '41 fixed-scale syndrome/basis/duration features plus two expert clipped logits/8 and their smooth absolute values;45 inputs,32-unit SiLU hidden layer,one free logit,other logit zero;no label/ID/position features;confidence features are fully differentiated', + 'validation': 'Uniform1024-shot per-condition screens by default, seed20261102; full validation required for checkpoint selection', + 'independence': 'This joint model uses all training rows; it does not retain the reserved-parent training-label holdout claim', + 'test_data_used': False, 'records': records, 'seconds': time.time() - started} + (args.output / 'provenance.json').write_text(json.dumps(provenance, indent=2) + '\n') + + +if __name__ == '__main__': + main() diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__data.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__data.py new file mode 100644 index 0000000000000000000000000000000000000000..7cbe1229eafbaaa3a06eaaeca9a0c38cb411f34f --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__data.py @@ -0,0 +1,95 @@ +"""Static physical features and authorized cached training/validation priors.""" +from pathlib import Path +import json,sys +import numpy as np +import stim +sys.path.insert(0,'/workspace/research/exact_d3') +from exact import parse_errors +from conditional import load_state + +ROOT=Path(__file__).resolve().parent + + +def build_features(row,package,max_ops=2048): + dem=stim.DetectorErrorModel.from_file(Path('/workspace/data/train')/row['noise']) + errors=parse_errors(dem);coords=dem.get_detector_coordinates() + if row['rounds']==1: + plan=dict(np.load(package/f"plans/{row['name']}.npz"));supports=[(ds,l) for ds,l,p in errors] + measured=plan['measured'] + else: + state=load_state(package/f"conditional_plans/{row['name']}.npz");plan=state['on'] + on=set(state['on_indices'].tolist());groups={} + for ds,l,p in errors: + key=tuple(sorted(ds&on)),l + if key[0] or key[1]:groups.setdefault(key,len(groups)) + supports=list(groups) + measured=np.where(plan['measured']>=0,state['on_indices'][np.maximum(plan['measured'],0)],-1) + assert int(plan['width'])<=14 + circuit=stim.Circuit.from_file(Path('/workspace/data/train')/row['circuit']) + qubits=circuit.get_final_qubit_coordinates() + first=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX']) + spaces=sorted(tuple(qubits[t.value][:2]) for t in first.targets_copy());assert len(spaces)==24 + idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()} + context=np.full((max_ops,120),600,np.int32);static=np.zeros((max_ops,129),np.float32) + n=len(plan['masks']);assert n<=max_ops + for op,source in enumerate(plan['source_indices']): + if source<0:continue + ds,logical=supports[source];t=min(int(coords[d][2]) for d in ds) if ds else 0 + for dt in range(-2,3): + for s,space in enumerate(spaces):context[op,(dt+2)*24+s]=idx.get((t+dt,space),600) + for d in ds: + c=coords[d];static[op,(int(c[2])-t+2)*24+spaces.index(tuple(c[:2]))]=1 + p=float(plan['probabilities'][op]);static[op,120]=np.log(max(p,1e-7)/max(1-p,1e-7))/8 + static[op,121:]=[logical,len(ds)/4,t/25,row['rounds']/25,t==0,t>=row['rounds']-1,row['basis']=='X',1] + grid=np.full((26,24),600,np.int32);measurement_indices=np.full(601,624,np.int32) + for d,c in coords.items(): + t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=d;measurement_indices[d]=t*24+s + return {'context':context,'static':static,'masks':np.pad(plan['masks'],(0,max_ops-n)), + 'measured':np.pad(measured,(0,max_ops-n),constant_values=-1), + 'valid':np.pad((plan['source_indices']>=0).astype(np.float32),(0,max_ops-n)), + 'grid':grid,'measurement_indices':measurement_indices, + 'counts':np.maximum((grid!=600).sum(axis=0),1).astype(np.float32),'operation_count':np.array(n,np.int32)} + + +def load_all(splits=('train','validation'),max_ops=2048,prior_pass=1,training_cache=None): + assert prior_pass in [1,3,5] + assert training_cache is None or prior_pass in [1,3] + rows=[r for r in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if r['distance']==5] + package=Path(json.loads(Path('/workspace/research/CURRENT.json').read_text())['package']) + plans=ROOT/'feature_plans';plans.mkdir(exist_ok=True);items=[] + for row in rows: + path=plans/f"{row['name']}.npz" + if not path.exists():np.savez(path,**build_features(row,package,max_ops)) + item=dict(np.load(path,allow_pickle=False));item['row']=row + if splits: + cache=np.load(Path('/workspace/research/exact_d3/turbo_cache')/f"{row['name']}.npz") + feedback=np.load(Path('/workspace/research/exact_d3/feedback5_cache')/f"{row['name']}.npz") if prior_pass>1 else None + for split in splits: + assert split in ['train','validation'] + arrays=np.load(Path('/workspace/data')/split/row['arrays']) + if split=='train' and training_cache is not None: + full=np.load(Path(training_cache)/f"{row['name']}.npz",allow_pickle=False) + indices=full['indices'];p=full[f'priors{prior_pass}'] + assert np.array_equal(arrays['sample_ids'][indices],full['sample_ids']) + physical_prediction=full['probabilities3'] + else: + indices=cache['train4096_indices'] if split=='train' else np.arange(len(arrays['labels'])) + key='train4096' if split=='train' else 'validation' + p=cache[key+'_on_prior'] if prior_pass==1 else feedback[f'{key}_priors{prior_pass}'] + physical_prediction=cache[key][:,0] if prior_pass==1 else feedback[key][:,prior_pass-1] + assert p.shape[1]==int(item['operation_count']) + if feedback is not None:assert np.array_equal(feedback['train4096_indices'],cache['train4096_indices']) + logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)) + item[split+'_base_logits']=np.pad(logits,((0,0),(0,max_ops-p.shape[1]))).astype(np.float32) + ds=np.unpackbits(arrays['detectors'][indices],axis=1,count=row['num_detectors'],bitorder='little') + item[split+'_dets']=np.pad(ds,((0,0),(0,601-ds.shape[1]))) + item[split+'_labels']=arrays['labels'][indices] + item[split+'_sample_ids']=arrays['sample_ids'][indices] + item[split+'_physical_probabilities']=physical_prediction.astype(np.float32) + items.append(item) + return items + + +if __name__=='__main__': + items=load_all(splits=()) + print(json.dumps({'conditions':len(items),'maximum_operations':max(int(x['operation_count']) for x in items)})) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__joint_mixture.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__joint_mixture.py new file mode 100644 index 0000000000000000000000000000000000000000..3d9d54003bcd8671bcd5332ee6ec050c80fdb99d --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__joint_mixture.py @@ -0,0 +1,75 @@ +"""Two trainable exact-decoder experts with a syndrome-only mixture gate.""" +import jax +import jax.numpy as jnp + +GATE_FEATURES = 41 + + +def gate_features(dets, grid, static): + """Shot-local features; no labels, IDs, expert probabilities, or batch statistics.""" + presence = grid != 600 + event = dets[:, grid].astype(jnp.float32) * presence[None] + count = jnp.maximum(presence.sum(axis=0), 1) + density = event.sum(axis=1) / count[None] + blocks = [density * 4] + for lag in [1, 2, 4, 8]: + valid = presence[:-lag] & presence[lag:] + denom = jnp.maximum(valid.sum(axis=0), 1) + site_valid = valid.any(axis=0) + a = event[:, :-lag] * valid[None] + b = event[:, lag:] * valid[None] + coincidence = (a * b).sum(axis=1) / denom[None] + covariance = coincidence - a.sum(axis=1) * b.sum(axis=1) / denom[None] ** 2 + divisor = jnp.maximum(site_valid.sum(), 1) + blocks.extend([(coincidence * site_valid).sum(axis=1, keepdims=True) * 8 / divisor, + (covariance * site_valid).sum(axis=1, keepdims=True) * 16 / divisor]) + valid_frame = presence.any(axis=1) + nframes = jnp.maximum(valid_frame.sum(), 1) + frame = event.sum(axis=2) / jnp.maximum(presence.sum(axis=1), 1)[None] + frame_mean = frame.sum(axis=1) / nframes + frame_var = (((frame - frame_mean[:, None]) ** 2) * valid_frame[None]).sum(axis=1) / nframes + rank = jnp.cumsum(valid_frame) - 1 + first_mask = valid_frame & (rank < jnp.maximum(nframes // 2, 1)) + last_mask = valid_frame & ~first_mask + first = (frame * first_mask[None]).sum(axis=1) / jnp.maximum(first_mask.sum(), 1) + last = (frame * last_mask[None]).sum(axis=1) / jnp.maximum(last_mask.sum(), 1) + last = jnp.where(last_mask.any(), last, first) + fraction = jnp.max(static[:, 124]) + basis = jnp.max(static[:, 127]) + blocks.append(4 * jnp.stack([density.mean(axis=1), density.std(axis=1), density.max(axis=1), + jnp.sqrt(jnp.maximum(frame_var, 0)), frame.max(axis=1), + jnp.abs(first - last)], axis=1)) + blocks.append(jnp.broadcast_to(jnp.stack([fraction, fraction ** 2, basis]), (len(dets), 3))) + result = jnp.concatenate(blocks, axis=1) + assert result.shape == (len(dets), GATE_FEATURES) + return result + + +def initialize_gate(seed, hidden=32): + key = jax.random.key(seed) + return {'w1': jax.random.normal(key, (GATE_FEATURES, hidden)) * jnp.sqrt(2 / GATE_FEATURES), + 'b1': jnp.zeros(hidden), 'w2': jnp.zeros((hidden, 1)), 'b2': jnp.zeros(1)} + + +def gate_logit(parameters, features): + hidden = jax.nn.silu(features @ parameters['w1'] + parameters['b1']) + return (hidden @ parameters['w2'] + parameters['b2'])[:, 0] + + +def mixture_terms(losses, logit): + """Stable BCE and exact expert/gate adjoints from per-expert BCE losses. + + losses has shape [batch,2]. Responsibilities multiply each expert BCE + gradient; gate_adjoint is d(BCE mixture)/d(single free gate logit). + """ + logits = jnp.stack([logit, jnp.zeros_like(logit)], axis=1) + log_a = jax.nn.log_softmax(logits, axis=1) + log_c = jax.scipy.special.logsumexp(log_a - losses, axis=1) + responsibility = jnp.exp(log_a - losses - log_c[:, None]) + a = jnp.exp(log_a) + return -log_c, responsibility, a[:, 0] - responsibility[:, 0], a + + +def mix_predictions(predictions, logit): + a = jax.nn.sigmoid(logit) + return a * predictions[:, 0] + (1 - a) * predictions[:, 1] diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__model.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__model.py new file mode 100644 index 0000000000000000000000000000000000000000..bf5272d4652dd29dab2b118849d17648019d93a3 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_d5__model.py @@ -0,0 +1,55 @@ +"""Small shared network corrects soft-conditioned relevant-CSS edge logits.""" +import jax +import jax.numpy as jnp + + +def initialize(seed,hidden=64,input_features=394): + assert input_features in (394,414) + keys=jax.random.split(jax.random.key(seed),3) + return {'w1':jax.random.normal(keys[0],(input_features,hidden))*jnp.sqrt(2/input_features),'b1':jnp.zeros(hidden), + 'w2':jax.random.normal(keys[1],(hidden,hidden))*jnp.sqrt(2/hidden),'b2':jnp.zeros(hidden), + 'w3':jax.random.normal(keys[2],(hidden,1))*.001,'b3':jnp.zeros(1)} + + +def endpoint_features(events,measurements,density,static): + """Twenty endpoint/history summaries computed solely from the input syndrome.""" + support=static[:,:120].reshape(-1,5,24) + selected=jnp.max(support,axis=1) + endpoint_counts=jnp.maximum(support.sum(axis=-1),1) + spatial_count=jnp.maximum(selected.sum(axis=-1),1) + event_frames=events.reshape(len(events),-1,5,24) + measurement_frames=measurements.reshape(len(events),-1,5,24) + endpoint_events=(event_frames*support[None,:,:,:]).sum(axis=-1) + endpoint_measurements=(measurement_frames*support[None,:,:,:]).sum(axis=-1) + spatial_events=(event_frames*selected[None,:,None,:]).sum(axis=-1)/spatial_count[None,:,None] + endpoint_total=endpoint_events.sum(axis=-1) + endpoint_fraction=endpoint_total/jnp.maximum(support.sum(axis=(1,2)),1)[None,:] + endpoint_parity=jnp.mod(endpoint_total,2) + selected_density=(density[:,None,:]*selected[None,:,:]).sum(axis=-1)/spatial_count[None,:] + adjacent=(event_frames[:,:,:-1,:]*event_frames[:,:,1:,:]*selected[None,:,None,:]).sum(axis=(2,3))/(4*spatial_count[None,:]) + measurement_mean=(measurement_frames*selected[None,:,None,:]).sum(axis=(2,3))/(5*spatial_count[None,:]) + return jnp.concatenate([ + endpoint_events/endpoint_counts[None,:,:], + endpoint_measurements/endpoint_counts[None,:,:],spatial_events, + selected_density[:,:,None],endpoint_fraction[:,:,None],endpoint_parity[:,:,None], + adjacent[:,:,None],measurement_mean[:,:,None]],axis=-1) + + +def probabilities(parameters,dets,base_logits,context,static,valid,grid,measurement_indices,counts): + event_grid=dets[:,grid] + measured=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).reshape(len(dets),624) + measured=jnp.pad(measured,((0,0),(0,1))) + events=dets[:,context].astype(jnp.float32) + measurements=measured[:,measurement_indices[context]].astype(jnp.float32) + density=jnp.sum(event_grid,axis=1)/counts[None,:] + features=jnp.concatenate([events,measurements, + jnp.broadcast_to(density[:,None,:],(len(dets),len(context),24)), + jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),base_logits[:,:,None]/8],axis=-1) + if parameters['w1'].shape[0]==414: + features=jnp.concatenate([features,endpoint_features(events,measurements,density,static)],axis=-1) + else: + assert parameters['w1'].shape[0]==394 + h=jax.nn.silu(features@parameters['w1']+parameters['b1']) + h=jax.nn.silu(h@parameters['w2']+parameters['b2']) + delta=2*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0]) + return (jax.nn.sigmoid(base_logits+delta)*valid[None,:]).T diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_exact__checkpoint_gradient.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_exact__checkpoint_gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..b567a7a009cbed51d34288e7492dc5ee45710488 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/confidence_joint1/learned_exact__checkpoint_gradient.py @@ -0,0 +1,73 @@ +"""Exact logical BCE gradient with block recomputation of frontier histories.""" +import jax +import jax.numpy as jnp + + +def make_loss_and_grad(width, block_size=32): + indices = jnp.arange(1 << width, dtype=jnp.int32) + + @jax.jit + def evaluate(dets, labels, probabilities, masks, measured): + nops, batch = probabilities.shape + padding = (-nops) % block_size + p = jnp.pad(probabilities, ((0, padding), (0, 0))) + m = jnp.pad(masks, (0, padding)) + d = jnp.pad(measured, (0, padding), constant_values=-1) + blocks = (p.reshape(-1, block_size, batch), m.reshape(-1, block_size), + d.reshape(-1, block_size)) + + def forward(f, args): + probability, mask, detector = args + + def error(f): + out = (1 - probability[:, None]) * f + probability[:, None] * f[:, indices ^ mask] + return out, jnp.ones(batch) + + def project(f): + dst = (indices[None, :] & ~mask) | (dets[:, detector, None].astype(jnp.int32) * mask) + g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask) == 0) + norm = jnp.maximum(g.sum(axis=1), 1e-30) + return g / norm[:, None], norm + + out, norm = jax.lax.cond(detector < 0, error, project, f) + return out, (f, norm) + + def forward_block(f, args): + def step(carry, item): + result, _ = forward(carry, item) + return result, None + out, _ = jax.lax.scan(step, f, args) + return out, f + + initial = jnp.zeros((batch, 1 << width), jnp.float32).at[:, 0].set(1) + f, checkpoints = jax.lax.scan(forward_block, initial, blocks) + indicator = ((indices[None, :] & 1) == labels[:, None]) + correct = jnp.maximum(jnp.sum(f * indicator, axis=1), 1e-10) + prediction = jnp.sum(f[:, 1::2], axis=1) + terminal = 1 - indicator / correct[:, None] + + def backward(b, args): + probability, mask, detector, old, norm = args + + def error(b): + flipped = b[:, indices ^ mask] + grad = jnp.sum(old * (flipped - b), axis=1) + return (1 - probability[:, None]) * b + probability[:, None] * flipped, grad + + def project(b): + obs = ((indices[None, :] & mask) == dets[:, detector, None].astype(jnp.int32) * mask) + values = b[:, indices & ~mask] + mean = jnp.sum(old * obs * values, axis=1) / norm + return (values - mean[:, None]) * obs / norm[:, None], jnp.zeros(batch) + + return jax.lax.cond(detector < 0, error, project, b) + + def backward_block(b, args): + probabilities, masks, measured, checkpoint = args + _, (history, norms) = jax.lax.scan(forward, checkpoint, (probabilities, masks, measured)) + return jax.lax.scan(backward, b, (probabilities, masks, measured, history, norms), reverse=True) + + _, gradients = jax.lax.scan(backward_block, terminal, (*blocks, checkpoints), reverse=True) + return -jnp.log(correct), prediction, gradients.reshape(-1, batch)[:nops] + + return evaluate diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/exact_d3__exact.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/exact_d3__exact.py new file mode 100644 index 0000000000000000000000000000000000000000..1ae5a8eb3e91ada61a5870063470a6d3453cf0e0 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/exact_d3__exact.py @@ -0,0 +1,213 @@ +"""Exact detector-error-model contraction by bounded-frontier elimination.""" +import collections +import numpy as np +import stim + + +def parse_errors(dem): + errors = [] + for ins in dem.flattened(): + if ins.type != 'error': + continue + ds, logical = set(), 0 + for t in ins.targets_copy(): + if t.is_relative_detector_id(): + ds.symmetric_difference_update([t.val]) + elif t.is_logical_observable_id(): + assert t.val == 0 + logical ^= 1 + errors.append((ds, logical, ins.args_copy()[0])) + return errors + + +def elimination_order(dem, errors): + blocks = collections.defaultdict(list) + for d, c in dem.get_detector_coordinates().items(): + blocks[c[-1]].append(d) + pending = [ds for ds, _, _ in errors if ds] + active, used, order = set(), set(), [] + for _, block in sorted(blocks.items()): + remain = set(block) + while remain: + def score(d): + new = set().union(*(e for e in pending if d in e)) - used + return len(active | new), -sum(d in e for e in pending), d + d = min(remain, key=score) + related = [e for e in pending if d in e] + active |= set().union(*related) - used + active.discard(d) + pending = [e for e in pending if d not in e] + used.add(d) + remain.remove(d) + order.append(d) + assert sorted(order) == list(range(dem.num_detectors)) + return order + + +def make_plan(dem): + errors = parse_errors(dem) + order = elimination_order(dem, errors) + rank = {d: i for i, d in enumerate(order)} + groups = collections.defaultdict(list) + for source_index, (ds, logical, p) in enumerate(errors): + first = min(ds, key=rank.get) if ds else order[0] + groups[first].append((ds, logical, p, source_index)) + slots, probabilities, masks, measured, source_indices = {}, [], [], [], [] + width = 1 + for d in order: + related = groups[d] + needed = set().union(*(ds for ds, _, _, _ in related)) | {d} + for node in sorted(needed): + if node not in slots: + free = next(i for i in range(1, 64) if i not in slots.values()) + slots[node] = free + width = max(width, free+1) + for ds, logical, p, source_index in related: + mask = logical + for node in ds: + mask ^= 1 << slots[node] + probabilities.append(p) + masks.append(mask) + measured.append(-1) + source_indices.append(source_index) + probabilities.append(0) + masks.append(1 << slots.pop(d)) + measured.append(d) + source_indices.append(-1) + assert not slots + return {'probabilities': np.array(probabilities, np.float32), + 'masks': np.array(masks, np.int32), 'measured': np.array(measured, np.int32), + 'width': np.array(width, np.int32), 'num_detectors': np.array(dem.num_detectors, np.int32), + 'source_indices': np.array(source_indices, np.int32), + 'order': np.array(order, np.int32)} + + +def make_decoder(width): + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + @jax.jit + def decode(dets, probabilities, masks, measured): + f = jnp.zeros((dets.shape[0], 1 << width), jnp.float32).at[:, 0].set(1) + def step(f, args): + p, mask, d = args + def error(f): + prob = p[:, None] if p.ndim else p + return (1-prob)*f + prob*f[:, indices ^ mask] + def project(f): + obs = dets[:, d].astype(jnp.int32) + dst = (indices[None, :] & ~mask) | (obs[:, None]*mask) + g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask)==0) + return g / jnp.maximum(jnp.sum(g, axis=1, keepdims=True), 1e-30) + return jax.lax.cond(d < 0, error, project, f), None + f, _ = jax.lax.scan(step, f, (probabilities, masks, measured)) + return jnp.sum(f[:, 1::2], axis=1) / jnp.maximum(jnp.sum(f, axis=1), 1e-30) + return decode + + +def make_marginals(width): + """Per-shot derivatives of log syndrome probability give all error marginals.""" + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + def log_partition(dets, probabilities, masks, measured): + f = jnp.zeros(1 << width, jnp.float32).at[0].set(1) + def step(carry, args): + f, logz = carry + p, mask, d = args + def error(carry): + f, logz = carry + return ((1-p)*f + p*f[indices ^ mask], logz) + def project(carry): + f, logz = carry + dst = (indices & ~mask) | (dets[d].astype(jnp.int32)*mask) + g = f[dst] * ((indices & mask)==0) + norm = jnp.maximum(jnp.sum(g), 1e-30) + return g/norm, logz+jnp.log(norm) + return jax.lax.cond(d<0, error, project, carry), None + (_, logz), _ = jax.lax.scan(jax.checkpoint(step), (f, jnp.float32(0)), (probabilities, masks, measured)) + return logz + return jax.jit(jax.vmap(jax.value_and_grad(log_partition, argnums=1), in_axes=(0,None,None,None))) + + +def make_marginals_fb(width, return_observable=False): + """Forward/backward contraction without generic gather-gradient scatter.""" + import jax + import jax.numpy as jnp + indices = jnp.arange(1 << width, dtype=jnp.int32) + # The syndrome likelihood marginalizes the unobserved logical bit. Keep + # that bit in the forward state for its output, but omit it from histories + # and backward messages, halving the largest buffers. + backward_width=width-1 if return_observable else width + backward_indices=jnp.arange(1 << backward_width,dtype=jnp.int32) + @jax.jit + def marginals(dets, probabilities, masks, measured): + f=jnp.zeros((dets.shape[0],1<>1 if return_observable else masks + _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__data.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__data.py new file mode 100644 index 0000000000000000000000000000000000000000..7cbe1229eafbaaa3a06eaaeca9a0c38cb411f34f --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__data.py @@ -0,0 +1,95 @@ +"""Static physical features and authorized cached training/validation priors.""" +from pathlib import Path +import json,sys +import numpy as np +import stim +sys.path.insert(0,'/workspace/research/exact_d3') +from exact import parse_errors +from conditional import load_state + +ROOT=Path(__file__).resolve().parent + + +def build_features(row,package,max_ops=2048): + dem=stim.DetectorErrorModel.from_file(Path('/workspace/data/train')/row['noise']) + errors=parse_errors(dem);coords=dem.get_detector_coordinates() + if row['rounds']==1: + plan=dict(np.load(package/f"plans/{row['name']}.npz"));supports=[(ds,l) for ds,l,p in errors] + measured=plan['measured'] + else: + state=load_state(package/f"conditional_plans/{row['name']}.npz");plan=state['on'] + on=set(state['on_indices'].tolist());groups={} + for ds,l,p in errors: + key=tuple(sorted(ds&on)),l + if key[0] or key[1]:groups.setdefault(key,len(groups)) + supports=list(groups) + measured=np.where(plan['measured']>=0,state['on_indices'][np.maximum(plan['measured'],0)],-1) + assert int(plan['width'])<=14 + circuit=stim.Circuit.from_file(Path('/workspace/data/train')/row['circuit']) + qubits=circuit.get_final_qubit_coordinates() + first=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX']) + spaces=sorted(tuple(qubits[t.value][:2]) for t in first.targets_copy());assert len(spaces)==24 + idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()} + context=np.full((max_ops,120),600,np.int32);static=np.zeros((max_ops,129),np.float32) + n=len(plan['masks']);assert n<=max_ops + for op,source in enumerate(plan['source_indices']): + if source<0:continue + ds,logical=supports[source];t=min(int(coords[d][2]) for d in ds) if ds else 0 + for dt in range(-2,3): + for s,space in enumerate(spaces):context[op,(dt+2)*24+s]=idx.get((t+dt,space),600) + for d in ds: + c=coords[d];static[op,(int(c[2])-t+2)*24+spaces.index(tuple(c[:2]))]=1 + p=float(plan['probabilities'][op]);static[op,120]=np.log(max(p,1e-7)/max(1-p,1e-7))/8 + static[op,121:]=[logical,len(ds)/4,t/25,row['rounds']/25,t==0,t>=row['rounds']-1,row['basis']=='X',1] + grid=np.full((26,24),600,np.int32);measurement_indices=np.full(601,624,np.int32) + for d,c in coords.items(): + t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=d;measurement_indices[d]=t*24+s + return {'context':context,'static':static,'masks':np.pad(plan['masks'],(0,max_ops-n)), + 'measured':np.pad(measured,(0,max_ops-n),constant_values=-1), + 'valid':np.pad((plan['source_indices']>=0).astype(np.float32),(0,max_ops-n)), + 'grid':grid,'measurement_indices':measurement_indices, + 'counts':np.maximum((grid!=600).sum(axis=0),1).astype(np.float32),'operation_count':np.array(n,np.int32)} + + +def load_all(splits=('train','validation'),max_ops=2048,prior_pass=1,training_cache=None): + assert prior_pass in [1,3,5] + assert training_cache is None or prior_pass in [1,3] + rows=[r for r in json.loads(Path('/workspace/data/train/manifest.json').read_text())['conditions'] if r['distance']==5] + package=Path(json.loads(Path('/workspace/research/CURRENT.json').read_text())['package']) + plans=ROOT/'feature_plans';plans.mkdir(exist_ok=True);items=[] + for row in rows: + path=plans/f"{row['name']}.npz" + if not path.exists():np.savez(path,**build_features(row,package,max_ops)) + item=dict(np.load(path,allow_pickle=False));item['row']=row + if splits: + cache=np.load(Path('/workspace/research/exact_d3/turbo_cache')/f"{row['name']}.npz") + feedback=np.load(Path('/workspace/research/exact_d3/feedback5_cache')/f"{row['name']}.npz") if prior_pass>1 else None + for split in splits: + assert split in ['train','validation'] + arrays=np.load(Path('/workspace/data')/split/row['arrays']) + if split=='train' and training_cache is not None: + full=np.load(Path(training_cache)/f"{row['name']}.npz",allow_pickle=False) + indices=full['indices'];p=full[f'priors{prior_pass}'] + assert np.array_equal(arrays['sample_ids'][indices],full['sample_ids']) + physical_prediction=full['probabilities3'] + else: + indices=cache['train4096_indices'] if split=='train' else np.arange(len(arrays['labels'])) + key='train4096' if split=='train' else 'validation' + p=cache[key+'_on_prior'] if prior_pass==1 else feedback[f'{key}_priors{prior_pass}'] + physical_prediction=cache[key][:,0] if prior_pass==1 else feedback[key][:,prior_pass-1] + assert p.shape[1]==int(item['operation_count']) + if feedback is not None:assert np.array_equal(feedback['train4096_indices'],cache['train4096_indices']) + logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)) + item[split+'_base_logits']=np.pad(logits,((0,0),(0,max_ops-p.shape[1]))).astype(np.float32) + ds=np.unpackbits(arrays['detectors'][indices],axis=1,count=row['num_detectors'],bitorder='little') + item[split+'_dets']=np.pad(ds,((0,0),(0,601-ds.shape[1]))) + item[split+'_labels']=arrays['labels'][indices] + item[split+'_sample_ids']=arrays['sample_ids'][indices] + item[split+'_physical_probabilities']=physical_prediction.astype(np.float32) + items.append(item) + return items + + +if __name__=='__main__': + items=load_all(splits=()) + print(json.dumps({'conditions':len(items),'maximum_operations':max(int(x['operation_count']) for x in items)})) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__model.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__model.py new file mode 100644 index 0000000000000000000000000000000000000000..bf5272d4652dd29dab2b118849d17648019d93a3 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__model.py @@ -0,0 +1,55 @@ +"""Small shared network corrects soft-conditioned relevant-CSS edge logits.""" +import jax +import jax.numpy as jnp + + +def initialize(seed,hidden=64,input_features=394): + assert input_features in (394,414) + keys=jax.random.split(jax.random.key(seed),3) + return {'w1':jax.random.normal(keys[0],(input_features,hidden))*jnp.sqrt(2/input_features),'b1':jnp.zeros(hidden), + 'w2':jax.random.normal(keys[1],(hidden,hidden))*jnp.sqrt(2/hidden),'b2':jnp.zeros(hidden), + 'w3':jax.random.normal(keys[2],(hidden,1))*.001,'b3':jnp.zeros(1)} + + +def endpoint_features(events,measurements,density,static): + """Twenty endpoint/history summaries computed solely from the input syndrome.""" + support=static[:,:120].reshape(-1,5,24) + selected=jnp.max(support,axis=1) + endpoint_counts=jnp.maximum(support.sum(axis=-1),1) + spatial_count=jnp.maximum(selected.sum(axis=-1),1) + event_frames=events.reshape(len(events),-1,5,24) + measurement_frames=measurements.reshape(len(events),-1,5,24) + endpoint_events=(event_frames*support[None,:,:,:]).sum(axis=-1) + endpoint_measurements=(measurement_frames*support[None,:,:,:]).sum(axis=-1) + spatial_events=(event_frames*selected[None,:,None,:]).sum(axis=-1)/spatial_count[None,:,None] + endpoint_total=endpoint_events.sum(axis=-1) + endpoint_fraction=endpoint_total/jnp.maximum(support.sum(axis=(1,2)),1)[None,:] + endpoint_parity=jnp.mod(endpoint_total,2) + selected_density=(density[:,None,:]*selected[None,:,:]).sum(axis=-1)/spatial_count[None,:] + adjacent=(event_frames[:,:,:-1,:]*event_frames[:,:,1:,:]*selected[None,:,None,:]).sum(axis=(2,3))/(4*spatial_count[None,:]) + measurement_mean=(measurement_frames*selected[None,:,None,:]).sum(axis=(2,3))/(5*spatial_count[None,:]) + return jnp.concatenate([ + endpoint_events/endpoint_counts[None,:,:], + endpoint_measurements/endpoint_counts[None,:,:],spatial_events, + selected_density[:,:,None],endpoint_fraction[:,:,None],endpoint_parity[:,:,None], + adjacent[:,:,None],measurement_mean[:,:,None]],axis=-1) + + +def probabilities(parameters,dets,base_logits,context,static,valid,grid,measurement_indices,counts): + event_grid=dets[:,grid] + measured=(jnp.cumsum(event_grid.astype(jnp.int32),axis=1)&1).reshape(len(dets),624) + measured=jnp.pad(measured,((0,0),(0,1))) + events=dets[:,context].astype(jnp.float32) + measurements=measured[:,measurement_indices[context]].astype(jnp.float32) + density=jnp.sum(event_grid,axis=1)/counts[None,:] + features=jnp.concatenate([events,measurements, + jnp.broadcast_to(density[:,None,:],(len(dets),len(context),24)), + jnp.broadcast_to(static[None,:,:],(len(dets),*static.shape)),base_logits[:,:,None]/8],axis=-1) + if parameters['w1'].shape[0]==414: + features=jnp.concatenate([features,endpoint_features(events,measurements,density,static)],axis=-1) + else: + assert parameters['w1'].shape[0]==394 + h=jax.nn.silu(features@parameters['w1']+parameters['b1']) + h=jax.nn.silu(h@parameters['w2']+parameters['b2']) + delta=2*jnp.tanh((h@parameters['w3']+parameters['b3'])[...,0]) + return (jax.nn.sigmoid(base_logits+delta)*valid[None,:]).T diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__train.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__train.py new file mode 100644 index 0000000000000000000000000000000000000000..978be4e4764e5c606d611a47d1dd44340a252d61 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_d5__train.py @@ -0,0 +1,176 @@ +"""Train effective d5 CSS weights from random initialization on hardware labels.""" +import os +os.environ['OPENBLAS_NUM_THREADS']='1' +os.environ['OMP_NUM_THREADS']='1' +os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false' +from pathlib import Path +import argparse,json,time,sys,hashlib,shutil +import numpy as np +import jax,jax.numpy as jnp,optax +from model import initialize,probabilities +from data import load_all +sys.path.insert(0,'/workspace/research/learned_exact') +from gradient import make_loss_and_grad +from exact import make_decoder + + +def main(): + parser=argparse.ArgumentParser();parser.add_argument('--steps',type=int,default=1024) + parser.add_argument('--batch',type=int,default=256);parser.add_argument('--output',type=Path,required=True) + parser.add_argument('--validation-shots',type=int,default=512);parser.add_argument('--validation-batch',type=int,default=512) + parser.add_argument('--init-weights',type=Path);parser.add_argument('--learning-rate',type=float,default=.001) + parser.add_argument('--eval-every',type=int,default=256);parser.add_argument('--seed',type=int,default=20261101) + parser.add_argument('--initial-seed',type=int,default=20261101) + parser.add_argument('--prior-pass',type=int,choices=[1,3,5],default=1) + parser.add_argument('--training-cache',type=Path) + parser.add_argument('--gradient-block-size',type=int,default=0) + parser.add_argument('--bucket-operations',action='store_true') + parser.add_argument('--accumulate-conditions',type=int,default=1) + parser.add_argument('--uncertainty-weight-floor',type=float,default=1.) + parser.add_argument('--hidden-width',type=int,default=64) + parser.add_argument('--endpoint-features',action='store_true') + parser.add_argument('--reset-optimizer',action='store_true') + parser.add_argument('--reset-rng',action='store_true') + args=parser.parse_args();args.output.mkdir(parents=True,exist_ok=True) + assert args.accumulate_conditions>=1 and 0=.5)!=ys),jnp.sum(loss*example_weights)/jnp.sum(example_weights) + @jax.jit + def apply_gradient(parameters,state,grads): + changes,state=optimizer.update(grads,state,parameters) + return optax.apply_updates(parameters,changes),state,optax.global_norm(grads) + @jax.jit + def infer(parameters,ds,base,context,static,valid,masks,measured,grid,measurement_indices,counts): + p=probabilities(parameters,ds,base,context,static,valid,grid,measurement_indices,counts) + return decode(ds,p,masks,measured) + feature_names=['context','static','valid','masks','measured','grid','measurement_indices','counts'] + def evaluate(step): + results=[];start=time.time() + for item in dataset: + n=min(args.validation_shots,len(item['validation_labels'])) + ix=np.random.default_rng(20261102).choice(len(item['validation_labels']),n,replace=False) + length=((int(item['operation_count'])+511)//512)*512 + features=[item[k][:length] for k in feature_names[:5]]+[item[k] for k in feature_names[5:]] + parts=[] + for begin in range(0,n,args.validation_batch): + selected=ix[begin:begin+args.validation_batch];size=len(selected) + ds=np.pad(item['validation_dets'][selected],((0,args.validation_batch-size),(0,0))) + base=np.pad(item['validation_base_logits'][selected,:length],((0,args.validation_batch-size),(0,0))) + parts.append(np.asarray(infer(parameters,ds,base,*features))[:size]) + p=np.concatenate(parts);y=item['validation_labels'][ix].astype(np.float64) + pp=np.clip(p.astype(np.float64),1e-7,1-1e-7) + results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=y)), + 'negative_log_likelihood':float(np.mean(-y*np.log(pp)-(1-y)*np.log1p(-pp)))}) + result={'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])), + 'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])), + 'seconds':time.time()-start,'conditions':results} + (args.output/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n') + np.savez(args.output/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()}) + leaves,_=jax.tree_util.tree_flatten(state);np.savez(args.output/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)}) + (args.output/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n') + (args.output/f'checkpoint-{step}.json').write_text(json.dumps({'step':step,'training_samples':step*args.batch*args.accumulate_conditions, + 'unique_training_rows_seen_in_this_phase':sum(int(mask.sum()) for mask in seen), + 'weights_sha256':hashlib.sha256((args.output/f'weights-{step}.npz').read_bytes()).hexdigest(),'complete':True})+'\n') + print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True) + evaluate(0);records=[] + for step in range(1,args.steps+1): + total_grads=None;loss=0.;error=0.;objective=0. + for _ in range(args.accumulate_conditions): + condition_index=int(rng.integers(len(dataset)));item=dataset[condition_index] + ix=rng.integers(len(item['train_labels']),size=args.batch);seen[condition_index][ix]=True + length=((int(item['operation_count'])+511)//512)*512 if args.bucket_operations else len(item['valid']) + features=[item[k][:length] for k in feature_names[:5]]+[item[k] for k in feature_names[5:]] + physical=item['train_physical_probabilities'][ix] + example_weights=(args.uncertainty_weight_floor+(1-args.uncertainty_weight_floor)*4*physical*(1-physical)).astype(np.float32) + grads,batch_loss,batch_error,batch_objective=batch_gradient(parameters,item['train_dets'][ix],item['train_labels'][ix],item['train_base_logits'][ix,:length],*features,example_weights) + total_grads=grads if total_grads is None else jax.tree_util.tree_map(jnp.add,total_grads,grads) + loss+=batch_loss/args.accumulate_conditions;error+=batch_error/args.accumulate_conditions + objective+=batch_objective/args.accumulate_conditions + total_grads=jax.tree_util.tree_map(lambda g:g/args.accumulate_conditions,total_grads) + parameters,state,norm=apply_gradient(parameters,state,total_grads) + if step==1 or step%16==0: + r={'step':step,'loss':float(loss),'objective':float(objective),'error':float(error),'gradient_norm':float(norm),'elapsed':time.time()-started} + assert np.isfinite(r['loss']);records.append(r);print(json.dumps(r),flush=True) + if step%args.eval_every==0 or step==args.steps:evaluate(step) + provenance={'initialization':(f'Continue from the recorded session-trained checkpoint; original random initialization seed {args.initial_seed}' if args.init_weights else + f'All parameters initialized in this session: variance-scaled normal hidden layers, Normal(0,.001) output weights, zero biases, seed {args.initial_seed}'), + 'prior_pass':args.prior_pass,'initial_seed':args.initial_seed, + 'training_source_sha256':source_hashes,'runtime_versions':config['runtime_versions'], + 'hidden_width':actual_hidden, + 'input_features':input_features,'feature_mode':feature_mode, + 'architecture':f'Two {actual_hidden}-unit SiLU layers; {input_features} features; bounded 2*tanh correction to relevant-CSS edge logits from the recorded physical feedback pass; exact width-14 contraction predicts logical probability. D5 joint conditioning remains approximate.', + 'training':('All supplied training shots per each of all26 d5 conditions; uniform condition and within-condition sampling for optimizer batches.' if args.training_cache else + '4096 training shots per each of all 26 d5 conditions, sampled without replacement with seed 20261023. Uniform condition and within-condition sampling for optimizer batches.'), + 'training_cache':str(args.training_cache) if args.training_cache else None, + 'training_cache_provenance':json.loads((args.training_cache/'provenance.json').read_text()) if args.training_cache else None, + 'training_shots':sum(len(item['train_labels']) for item in dataset), + 'training_pool_interpretation':'Eligible training rows; optimizer samples conditions and rows with replacement. Distinct rows used in this phase are recorded separately.', + 'unique_training_rows_seen_in_this_phase':sum(int(mask.sum()) for mask in seen), + 'unique_rows_by_condition':{item['row']['name']:int(mask.sum()) for item,mask in zip(dataset,seen)}, + 'gradient_block_size':args.gradient_block_size, + 'bucket_operations':args.bucket_operations, + 'accumulate_conditions':args.accumulate_conditions, + 'effective_batch_size':args.batch*args.accumulate_conditions, + 'uncertainty_weight_floor':args.uncertainty_weight_floor, + 'example_weighting':('Uniform BCE' if args.uncertainty_weight_floor==1 else + 'Frozen physical pass3 confidence gives w=floor+(1-floor)*4*p*(1-p), normalized within each condition batch. All weights positive; full validation remains unweighted.'), + 'loss':'Conditional logical binary cross entropy, differentiated through exact relevant-CSS contraction; physical CSS feedback prior held fixed', + 'steps':args.steps,'batch':args.batch,'learning_rate':args.learning_rate,'sampling_seed':args.seed, + 'optimizer':'AdamW, weight decay 1e-4, global gradient norm clip 1','optimizer_restored':restored, + 'rng_restored':rng_restored, + 'explicit_optimizer_reset':args.reset_optimizer,'explicit_rng_reset':args.reset_rng, + 'sampling_state_source':str(rngfile) if rng_restored else f'Fresh NumPy default_rng seed {args.seed}', + 'starting_checkpoint':str(args.init_weights) if args.init_weights else None, + 'starting_checkpoint_sha256':hashlib.sha256(args.init_weights.read_bytes()).hexdigest() if args.init_weights else None, + 'starting_training_provenance':json.loads((args.init_weights.parent/'provenance.json').read_text()) if args.init_weights else None, + 'validation':'Uniform subset per all 26 conditions, sample seed 20261102; full validation required before publication', + 'validation_shots_per_condition':args.validation_shots,'test_data_used':False,'records':records} + (args.output/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n') + + +if __name__=='__main__':main() diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__checkpoint_gradient.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__checkpoint_gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..b567a7a009cbed51d34288e7492dc5ee45710488 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__checkpoint_gradient.py @@ -0,0 +1,73 @@ +"""Exact logical BCE gradient with block recomputation of frontier histories.""" +import jax +import jax.numpy as jnp + + +def make_loss_and_grad(width, block_size=32): + indices = jnp.arange(1 << width, dtype=jnp.int32) + + @jax.jit + def evaluate(dets, labels, probabilities, masks, measured): + nops, batch = probabilities.shape + padding = (-nops) % block_size + p = jnp.pad(probabilities, ((0, padding), (0, 0))) + m = jnp.pad(masks, (0, padding)) + d = jnp.pad(measured, (0, padding), constant_values=-1) + blocks = (p.reshape(-1, block_size, batch), m.reshape(-1, block_size), + d.reshape(-1, block_size)) + + def forward(f, args): + probability, mask, detector = args + + def error(f): + out = (1 - probability[:, None]) * f + probability[:, None] * f[:, indices ^ mask] + return out, jnp.ones(batch) + + def project(f): + dst = (indices[None, :] & ~mask) | (dets[:, detector, None].astype(jnp.int32) * mask) + g = jnp.take_along_axis(f, dst, axis=1) * ((indices & mask) == 0) + norm = jnp.maximum(g.sum(axis=1), 1e-30) + return g / norm[:, None], norm + + out, norm = jax.lax.cond(detector < 0, error, project, f) + return out, (f, norm) + + def forward_block(f, args): + def step(carry, item): + result, _ = forward(carry, item) + return result, None + out, _ = jax.lax.scan(step, f, args) + return out, f + + initial = jnp.zeros((batch, 1 << width), jnp.float32).at[:, 0].set(1) + f, checkpoints = jax.lax.scan(forward_block, initial, blocks) + indicator = ((indices[None, :] & 1) == labels[:, None]) + correct = jnp.maximum(jnp.sum(f * indicator, axis=1), 1e-10) + prediction = jnp.sum(f[:, 1::2], axis=1) + terminal = 1 - indicator / correct[:, None] + + def backward(b, args): + probability, mask, detector, old, norm = args + + def error(b): + flipped = b[:, indices ^ mask] + grad = jnp.sum(old * (flipped - b), axis=1) + return (1 - probability[:, None]) * b + probability[:, None] * flipped, grad + + def project(b): + obs = ((indices[None, :] & mask) == dets[:, detector, None].astype(jnp.int32) * mask) + values = b[:, indices & ~mask] + mean = jnp.sum(old * obs * values, axis=1) / norm + return (values - mean[:, None]) * obs / norm[:, None], jnp.zeros(batch) + + return jax.lax.cond(detector < 0, error, project, b) + + def backward_block(b, args): + probabilities, masks, measured, checkpoint = args + _, (history, norms) = jax.lax.scan(forward, checkpoint, (probabilities, masks, measured)) + return jax.lax.scan(backward, b, (probabilities, masks, measured, history, norms), reverse=True) + + _, gradients = jax.lax.scan(backward_block, terminal, (*blocks, checkpoints), reverse=True) + return -jnp.log(correct), prediction, gradients.reshape(-1, batch)[:nops] + + return evaluate diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__gradient.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..a593f553a8ba67f3ff02717ba99d33c0eeb697e8 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh2_full/learned_exact__gradient.py @@ -0,0 +1,43 @@ +"""Differentiable conditional logical likelihood through exact DEM elimination.""" +import jax +import jax.numpy as jnp + + +def make_loss_and_grad(width): + indices=jnp.arange(1<>1 if return_observable else masks + _,grad=jax.lax.scan(backward,jnp.ones((len(dets),1<=.5)!=a['labels'][:len(p)]), 'min': p.min(), 'max': p.max()}, flush=True) diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__data.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__data.py new file mode 100644 index 0000000000000000000000000000000000000000..c4a53919501917da89ad95a4807e26e9972b8426 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__data.py @@ -0,0 +1,73 @@ +from pathlib import Path +import json,sys +import numpy as np +import stim +sys.path.insert(0,'/workspace/research/exact_d3') +from exact import make_plan,parse_errors + + +def _attach_arrays(item,root,splits): + row=item['row'] + for split in splits: + a=np.load(root/split/row['arrays']);ds=np.unpackbits(a['detectors'],axis=1,count=row['num_detectors'],bitorder='little') + item[split+'_dets']=np.pad(ds,((0,0),(0,201-ds.shape[1]))) + item[split+'_labels']=a['labels'] + + +def load_all(max_ops=3072,splits=('train','validation')): + assert set(splits)<=set(['train','validation']) + root=Path('/workspace/data') + rows=[r for r in json.loads((root/'train/manifest.json').read_text())['conditions'] if r['distance']==3] + groups=sorted({r['group'] for r in rows});result=[] + cache=Path('/workspace/research/learned_exact')/f'feature_cache-v2-{max_ops}' + cache.mkdir(exist_ok=True) + for row in rows: + cached=cache/f"{row['name']}-{row['noise_sha256'][:12]}-{row['circuit_sha256'][:12]}.npz" + if cached.exists(): + item=dict(np.load(cached,allow_pickle=False));item['row']=row + _attach_arrays(item,root,splits);result.append(item);continue + dem=stim.DetectorErrorModel.from_file(root/'train'/row['noise']);plan=make_plan(dem) + assert int(plan['width'])<=10 + count=len(plan['masks']);assert count<=max_ops,(row['name'],count) + coords=dem.get_detector_coordinates() + circuit=stim.Circuit.from_file(root/'train'/row['circuit']) + qubit_coords=circuit.get_final_qubit_coordinates() + first_measurement=next(ins for ins in circuit.flattened() if ins.name in ['M','MX','MR','MRX']) + spaces=sorted(tuple(qubit_coords[t.value][:2]) for t in first_measurement.targets_copy()) + assert len(spaces)==8 + idx={(int(c[2]),tuple(c[:2])):d for d,c in coords.items()} + errors=parse_errors(dem) + context=np.full((max_ops,40),200,np.int32) + static=np.zeros((max_ops,57),np.float32) + for op,source in enumerate(plan['source_indices']): + if source<0:continue + ds,logical,p=errors[source] + t=min(int(coords[d][2]) for d in ds) if ds else 0 + for dt in range(-2,3): + for s,spatial in enumerate(spaces):context[op,(dt+2)*8+s]=idx.get((t+dt,spatial),200) + for d in ds: + c=coords[d];static[op,(int(c[2])-t+2)*8+spaces.index(tuple(c[:2]))]=1 + static[op,40]=np.log(max(p,1e-7)/(1-max(p,1e-7)))/8 + static[op,41]=logical;static[op,42]=len(ds)/4 + static[op,43]=t/25;static[op,44]=row['rounds']/25 + static[op,45]=t==0;static[op,46]=t>=row['rounds']-1 + static[op,47+groups.index(row['group'])]=1 + static[op,55]=row['basis']=='X';static[op,56]=1 + masks=np.pad(plan['masks'],(0,max_ops-count)) + measured=np.pad(plan['measured'],(0,max_ops-count),constant_values=-1) + p=np.pad(plan['probabilities'],(0,max_ops-count)) + valid=((p>0)&(measured<0)).astype(np.float32) + logits=np.log(np.clip(p,1e-7,1-1e-7)/np.clip(1-p,1e-7,1-1e-7)).astype(np.float32) + item={'row':row,'context':context,'static':static,'masks':masks,'measured':measured,'base_logits':logits,'valid':valid} + grid=np.full((26,8),200,np.int32) + measurement_indices=np.full(201,208,np.int32) + for detector,c in coords.items(): + t=int(c[2]);s=spaces.index(tuple(c[:2]));grid[t,s]=detector + measurement_indices[detector]=t*8+s + item['grid']=grid;item['measurement_indices']=measurement_indices + item['counts']=np.maximum((grid!=200).sum(axis=0),1).astype(np.float32) + temporary=cached.with_suffix('.tmp.npz') + np.savez(temporary,**{k:v for k,v in item.items() if k!='row'});temporary.replace(cached) + _attach_arrays(item,root,splits) + result.append(item) + return result diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__fresh_specialize_train.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__fresh_specialize_train.py new file mode 100644 index 0000000000000000000000000000000000000000..fb454c4b65ff7fdfa34bd8c65693a6bd3ed285b0 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__fresh_specialize_train.py @@ -0,0 +1,161 @@ +# Derived from specialize_train.py SHA256 5a2e7ba25969f4599cb65d60cbd53544fd77d7a6926ec0d03662b72b151acf95; fresh-seed parent provenance only, unchanged update equations. +"""Fine-tune eight existing session-trained d3 models on their respective groups.""" +import os +os.environ['OPENBLAS_NUM_THREADS']='1' +os.environ['OMP_NUM_THREADS']='1' +os.environ['XLA_PYTHON_CLIENT_PREALLOCATE']='false' +from pathlib import Path +import argparse, hashlib, json, shutil, sys, time +import numpy as np +import jax, jax.numpy as jnp, optax +from data import load_all +from temporal_model import probabilities +from gradient import make_loss_and_grad +sys.path.insert(0,'/workspace/research/exact_d3') +from exact import make_decoder + +FIELDS=['context','static','base_logits','valid','masks','measured','grid','measurement_indices','counts'] + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + +def main(): + parser=argparse.ArgumentParser() + parser.add_argument('--package',type=Path,required=True) + parser.add_argument('--output',type=Path,required=True) + parser.add_argument('--steps',type=int,default=256) + parser.add_argument('--eval-every',type=int,default=128) + parser.add_argument('--batch',type=int,default=1024) + parser.add_argument('--validation-shots',type=int,default=1024) + parser.add_argument('--validation-batch',type=int,default=1024) + parser.add_argument('--learning-rate',type=float,default=.0001) + parser.add_argument('--seed',type=int,default=20261200) + parser.add_argument('--groups',nargs='+') + args=parser.parse_args() + assert args.steps>0 and args.eval_every>0 and args.batch>0 + args.output.mkdir(parents=True,exist_ok=False) + config=json.loads((args.package/'model_config.json').read_text()) + groups=sorted(config['temporal_contextual']) + if args.groups: + assert set(args.groups)<=set(groups) + groups=[g for g in groups if g in args.groups] + assert groups + source=Path(__file__).resolve();research=source.parent.parent + source_hashes={} + snapshot=args.output/'training_source';snapshot.mkdir() + for path in [source,source.parent/'temporal_model.py',source.parent/'data.py', + source.parent/'gradient.py',research/'exact_d3/exact.py']: + name=str(path.relative_to(research)).replace('/','__') + shutil.copyfile(path,snapshot/name);source_hashes[name]=sha(path) + parents=args.output/'parents';parents.mkdir() + shutil.copyfile(args.package/'training_provenance.json',parents/'training_provenance.json') + shutil.copyfile(args.package/'model_config.json',parents/'model_config.json') + run_config={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()} + run_config.update(training_source_sha256=source_hashes, + runtime_versions={'jax':jax.__version__,'numpy':np.__version__,'optax':optax.__version__}, + parent_config_sha256=sha(parents/'model_config.json'), + parent_provenance_sha256=sha(parents/'training_provenance.json'), + train_manifest_sha256=sha('/workspace/data/train/manifest.json'), + validation_manifest_sha256=sha('/workspace/data/validation/manifest.json'), + groups=groups) + (args.output/'run_config.json').write_text(json.dumps(run_config,indent=2)+'\n') + started=time.time();dataset=load_all() + dataset=[item for item in dataset if item['row']['group'] in groups] + assert len(dataset)==13*len(groups) + optimizer=optax.chain(optax.clip_by_global_norm(1.),optax.adamw(args.learning_rate,weight_decay=1e-4)) + exact_gradient=make_loss_and_grad(10);exact_decode=make_decoder(10) + + @jax.jit + def update(parameters,state,ds,ys,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts): + p,pullback=jax.vjp(lambda w:probabilities(w,ds,context,static,base_logits,valid,grid,measurement_indices,counts),parameters) + loss,pred,g=exact_gradient(ds,ys,p,masks,measured) + grads=pullback(g/len(ds))[0] + changes,state=optimizer.update(grads,state,parameters) + return optax.apply_updates(parameters,changes),state,jnp.mean(loss),jnp.mean((pred>=.5)!=ys),optax.global_norm(grads) + + @jax.jit + def infer(parameters,ds,context,static,base_logits,valid,masks,measured,grid,measurement_indices,counts): + p=probabilities(parameters,ds,context,static,base_logits,valid,grid,measurement_indices,counts) + return exact_decode(ds,p,masks,measured) + + reports={} + for group_index,group in enumerate(groups): + items=[item for item in dataset if item['row']['group']==group] + assert sorted(item['row']['rounds'] for item in items)==list(range(1,26,2)) + out=args.output/group;out.mkdir() + settings=config['temporal_contextual'][group] + parent=args.package/settings['weights'];parent_copy=parents/f'{group}.npz' + shutil.copyfile(parent,parent_copy) + parameters={k:jnp.asarray(v) for k,v in dict(np.load(parent_copy,allow_pickle=False)).items()} + state=optimizer.init(parameters) + seed=args.seed+sorted(config['temporal_contextual']).index(group) + rng=np.random.default_rng(seed);seen=[np.zeros(len(i['train_labels']),bool) for i in items] + records=[] + + def evaluate(step): + results=[];begin=time.time() + for item in items: + n=min(args.validation_shots,len(item['validation_labels'])) + ix=np.random.default_rng(20261028).choice(len(item['validation_labels']),n,replace=False) + vd=item['validation_dets'][ix];vy=item['validation_labels'][ix];parts=[] + for start in range(0,n,args.validation_batch): + ds=vd[start:start+args.validation_batch];size=len(ds) + ds=np.pad(ds,((0,args.validation_batch-size),(0,0))) + parts.append(np.asarray(infer(parameters,ds,*[item[k] for k in FIELDS]))[:size]) + p=np.concatenate(parts);pp=np.clip(p.astype(np.float64),1e-7,1-1e-7);yy=vy.astype(np.float64) + results.append({'condition':item['row']['name'],'failure':float(np.mean((p>=.5)!=vy)), + 'negative_log_likelihood':float(np.mean(-yy*np.log(pp)-(1-yy)*np.log1p(-pp)))}) + result={'group':group,'step':step,'validation_failure':float(np.mean([r['failure'] for r in results])), + 'negative_log_likelihood':float(np.mean([r['negative_log_likelihood'] for r in results])), + 'seconds':time.time()-begin,'conditions':results} + (out/f'validation-{step}.json').write_text(json.dumps(result,indent=2)+'\n') + np.savez(out/f'weights-{step}.npz',**{k:np.asarray(v) for k,v in parameters.items()}) + leaves,_=jax.tree_util.tree_flatten(state) + np.savez(out/f'optimizer-{step}.npz',**{f'arr_{i}':np.asarray(v) for i,v in enumerate(leaves)}) + (out/f'rng-{step}.json').write_text(json.dumps(rng.bit_generator.state)+'\n') + checkpoint={'group':group,'step':step,'training_draws':step*args.batch, + 'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen), + 'unique_rows_by_condition':{i['row']['name']:int(x.sum()) for i,x in zip(items,seen)}, + 'weights':f'weights-{step}.npz','weights_sha256':sha(out/f'weights-{step}.npz'),'complete':True} + (out/f'checkpoint-{step}.json').write_text(json.dumps(checkpoint,indent=2)+'\n') + print(json.dumps({k:v for k,v in result.items() if k!='conditions'}),flush=True) + + evaluate(0) + for step in range(1,args.steps+1): + ci=int(rng.integers(len(items)));item=items[ci] + ix=rng.integers(len(item['train_labels']),size=args.batch);seen[ci][ix]=True + parameters,state,loss,error,norm=update(parameters,state,item['train_dets'][ix],item['train_labels'][ix],*[item[k] for k in FIELDS]) + if step==1 or step%16==0: + record={'group':group,'step':step,'loss':float(loss),'error':float(error), + 'gradient_norm':float(norm),'elapsed':time.time()-started} + assert np.isfinite(record['loss']);records.append(record);print(json.dumps(record),flush=True) + if step%args.eval_every==0 or step==args.steps:evaluate(step) + provenance={'initialization':'Continue the temporal component of the selected session-trained group decoder; no new random parameters', + 'original_initialization':'Fresh rich trunk seed20261300 and temporal encoder seed20261301; parent may be a recorded within-trajectory parameter average; all fitting occurred in this session', + 'group':group,'parent_model':settings,'parent_weights_sha256':sha(parent_copy), + 'parent_provenance_sha256':run_config['parent_provenance_sha256'], + 'parent_record':'../parents/training_provenance.json', + 'training':'Uniform sampling over all13 odd round counts for this geometry/basis group, supplied training labels only', + 'eligible_training_shots':sum(len(i['train_labels']) for i in items), + 'training_draws':args.steps*args.batch, + 'unique_training_rows_seen_in_this_phase':sum(int(x.sum()) for x in seen), + 'unique_rows_by_condition':{i['row']['name']:int(x.sum()) for i,x in zip(items,seen)}, + 'steps':args.steps,'batch_size':args.batch,'learning_rate':args.learning_rate, + 'optimizer':'Fresh AdamW moments for every group, weight decay1e-4, global norm clip1', + 'optimizer_restored':False,'rng_restored':False,'sampling_seed':seed, + 'validation':'Fixed random screen per condition using seed20261028; full validation is used by the separate selector', + 'validation_shots_requested_per_condition':args.validation_shots, + 'loss':'Uniform binary conditional logical likelihood through exact frontier contraction', + 'training_source_sha256':source_hashes,'test_data_used':False,'log':records} + (out/'provenance.json').write_text(json.dumps(provenance,indent=2)+'\n');reports[group]=provenance + (args.output/'provenance.json').write_text(json.dumps({'experiment':'group-specific d3 continuation','groups':reports, + 'initialization':'Continue session-trained selected temporal components; no new random parameters', + 'training':'Each group samples uniformly over its own13 durations; supplied training labels only', + 'eligible_training_shots':sum(len(i['train_labels']) for i in dataset), + 'steps':args.steps*len(groups),'steps_per_group':args.steps,'batch_size':args.batch, + 'learning_rate':args.learning_rate,'optimizer_restored':False,'rng_restored':False, + 'training_source_sha256':source_hashes, + 'run_config':run_config,'parent_record':'parents/training_provenance.json','new_random_parameters':0, + 'training_draws':args.steps*args.batch*len(groups),'test_data_used':False},indent=2)+'\n') + +if __name__=='__main__':main() diff --git a/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__gradient.py b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..a593f553a8ba67f3ff02717ba99d33c0eeb697e8 --- /dev/null +++ b/tasks/surface-code-decoding/surface-code-decoding-astra-xhigh-1h100-48h-20261020b/submissions/S040/training_sources/fresh_specialize1/learned_exact__gradient.py @@ -0,0 +1,43 @@ +"""Differentiable conditional logical likelihood through exact DEM elimination.""" +import jax +import jax.numpy as jnp + + +def make_loss_and_grad(width): + indices=jnp.arange(1<